1from . import multiarray
2
3__all__ = []
4
5# Generated with generator3.
6
7
8class generic(object):
9    """
10    Base class for numpy scalar types.
11
12        Class from which most (all?) numpy scalar types are derived.  For
13        consistency, exposes the same API as `ndarray`, despite many
14        consequent attributes being either "get-only," or completely irrelevant.
15        This is the class from which it is strongly suggested users should derive
16        custom scalar types.
17    """
18
19    def all(self, *args, **kwargs):  # real signature unknown
20        """
21        Not implemented (virtual attribute)
22
23            Class generic exists solely to derive numpy scalars from, and possesses,
24            albeit unimplemented, all the attributes of the ndarray class
25            so as to provide a uniform API.
26
27            See Also
28            --------
29            The corresponding attribute of the derived class of interest.
30        """
31        pass
32
33    def any(self, *args, **kwargs):  # real signature unknown
34        """
35        Not implemented (virtual attribute)
36
37            Class generic exists solely to derive numpy scalars from, and possesses,
38            albeit unimplemented, all the attributes of the ndarray class
39            so as to provide a uniform API.
40
41            See Also
42            --------
43            The corresponding attribute of the derived class of interest.
44        """
45        pass
46
47    def argmax(self, *args, **kwargs):  # real signature unknown
48        """
49        Not implemented (virtual attribute)
50
51            Class generic exists solely to derive numpy scalars from, and possesses,
52            albeit unimplemented, all the attributes of the ndarray class
53            so as to provide a uniform API.
54
55            See Also
56            --------
57            The corresponding attribute of the derived class of interest.
58        """
59        pass
60
61    def argmin(self, *args, **kwargs):  # real signature unknown
62        """
63        Not implemented (virtual attribute)
64
65            Class generic exists solely to derive numpy scalars from, and possesses,
66            albeit unimplemented, all the attributes of the ndarray class
67            so as to provide a uniform API.
68
69            See Also
70            --------
71            The corresponding attribute of the derived class of interest.
72        """
73        pass
74
75    def argsort(self, *args, **kwargs):  # real signature unknown
76        """
77        Not implemented (virtual attribute)
78
79            Class generic exists solely to derive numpy scalars from, and possesses,
80            albeit unimplemented, all the attributes of the ndarray class
81            so as to provide a uniform API.
82
83            See Also
84            --------
85            The corresponding attribute of the derived class of interest.
86        """
87        pass
88
89    def astype(self, *args, **kwargs):  # real signature unknown
90        """
91        Not implemented (virtual attribute)
92
93            Class generic exists solely to derive numpy scalars from, and possesses,
94            albeit unimplemented, all the attributes of the ndarray class
95            so as to provide a uniform API.
96
97            See Also
98            --------
99            The corresponding attribute of the derived class of interest.
100        """
101        pass
102
103    def byteswap(self, *args, **kwargs):  # real signature unknown
104        """
105        Not implemented (virtual attribute)
106
107            Class generic exists solely to derive numpy scalars from, and possesses,
108            albeit unimplemented, all the attributes of the ndarray class so as to
109            provide a uniform API.
110
111            See Also
112            --------
113            The corresponding attribute of the derived class of interest.
114        """
115        pass
116
117    def choose(self, *args, **kwargs):  # real signature unknown
118        """
119        Not implemented (virtual attribute)
120
121            Class generic exists solely to derive numpy scalars from, and possesses,
122            albeit unimplemented, all the attributes of the ndarray class
123            so as to provide a uniform API.
124
125            See Also
126            --------
127            The corresponding attribute of the derived class of interest.
128        """
129        pass
130
131    def clip(self, *args, **kwargs):  # real signature unknown
132        """
133        Not implemented (virtual attribute)
134
135            Class generic exists solely to derive numpy scalars from, and possesses,
136            albeit unimplemented, all the attributes of the ndarray class
137            so as to provide a uniform API.
138
139            See Also
140            --------
141            The corresponding attribute of the derived class of interest.
142        """
143        pass
144
145    def compress(self, *args, **kwargs):  # real signature unknown
146        """
147        Not implemented (virtual attribute)
148
149            Class generic exists solely to derive numpy scalars from, and possesses,
150            albeit unimplemented, all the attributes of the ndarray class
151            so as to provide a uniform API.
152
153            See Also
154            --------
155            The corresponding attribute of the derived class of interest.
156        """
157        pass
158
159    def conj(self, *args, **kwargs):  # real signature unknown
160        pass
161
162    def conjugate(self, *args, **kwargs):  # real signature unknown
163        """
164        Not implemented (virtual attribute)
165
166            Class generic exists solely to derive numpy scalars from, and possesses,
167            albeit unimplemented, all the attributes of the ndarray class
168            so as to provide a uniform API.
169
170            See Also
171            --------
172            The corresponding attribute of the derived class of interest.
173        """
174        pass
175
176    def copy(self, *args, **kwargs):  # real signature unknown
177        """
178        Not implemented (virtual attribute)
179
180            Class generic exists solely to derive numpy scalars from, and possesses,
181            albeit unimplemented, all the attributes of the ndarray class
182            so as to provide a uniform API.
183
184            See Also
185            --------
186            The corresponding attribute of the derived class of interest.
187        """
188        pass
189
190    def cumprod(self, *args, **kwargs):  # real signature unknown
191        """
192        Not implemented (virtual attribute)
193
194            Class generic exists solely to derive numpy scalars from, and possesses,
195            albeit unimplemented, all the attributes of the ndarray class
196            so as to provide a uniform API.
197
198            See Also
199            --------
200            The corresponding attribute of the derived class of interest.
201        """
202        pass
203
204    def cumsum(self, *args, **kwargs):  # real signature unknown
205        """
206        Not implemented (virtual attribute)
207
208            Class generic exists solely to derive numpy scalars from, and possesses,
209            albeit unimplemented, all the attributes of the ndarray class
210            so as to provide a uniform API.
211
212            See Also
213            --------
214            The corresponding attribute of the derived class of interest.
215        """
216        pass
217
218    def diagonal(self, *args, **kwargs):  # real signature unknown
219        """
220        Not implemented (virtual attribute)
221
222            Class generic exists solely to derive numpy scalars from, and possesses,
223            albeit unimplemented, all the attributes of the ndarray class
224            so as to provide a uniform API.
225
226            See Also
227            --------
228            The corresponding attribute of the derived class of interest.
229        """
230        pass
231
232    def dump(self, *args, **kwargs):  # real signature unknown
233        """
234        Not implemented (virtual attribute)
235
236            Class generic exists solely to derive numpy scalars from, and possesses,
237            albeit unimplemented, all the attributes of the ndarray class
238            so as to provide a uniform API.
239
240            See Also
241            --------
242            The corresponding attribute of the derived class of interest.
243        """
244        pass
245
246    def dumps(self, *args, **kwargs):  # real signature unknown
247        """
248        Not implemented (virtual attribute)
249
250            Class generic exists solely to derive numpy scalars from, and possesses,
251            albeit unimplemented, all the attributes of the ndarray class
252            so as to provide a uniform API.
253
254            See Also
255            --------
256            The corresponding attribute of the derived class of interest.
257        """
258        pass
259
260    def fill(self, *args, **kwargs):  # real signature unknown
261        """
262        Not implemented (virtual attribute)
263
264            Class generic exists solely to derive numpy scalars from, and possesses,
265            albeit unimplemented, all the attributes of the ndarray class
266            so as to provide a uniform API.
267
268            See Also
269            --------
270            The corresponding attribute of the derived class of interest.
271        """
272        pass
273
274    def flatten(self, *args, **kwargs):  # real signature unknown
275        """
276        Not implemented (virtual attribute)
277
278            Class generic exists solely to derive numpy scalars from, and possesses,
279            albeit unimplemented, all the attributes of the ndarray class
280            so as to provide a uniform API.
281
282            See Also
283            --------
284            The corresponding attribute of the derived class of interest.
285        """
286        pass
287
288    def getfield(self, *args, **kwargs):  # real signature unknown
289        """
290        Not implemented (virtual attribute)
291
292            Class generic exists solely to derive numpy scalars from, and possesses,
293            albeit unimplemented, all the attributes of the ndarray class
294            so as to provide a uniform API.
295
296            See Also
297            --------
298            The corresponding attribute of the derived class of interest.
299        """
300        pass
301
302    def item(self, *args, **kwargs):  # real signature unknown
303        """
304        Not implemented (virtual attribute)
305
306            Class generic exists solely to derive numpy scalars from, and possesses,
307            albeit unimplemented, all the attributes of the ndarray class
308            so as to provide a uniform API.
309
310            See Also
311            --------
312            The corresponding attribute of the derived class of interest.
313        """
314        pass
315
316    def itemset(self, *args, **kwargs):  # real signature unknown
317        """
318        Not implemented (virtual attribute)
319
320            Class generic exists solely to derive numpy scalars from, and possesses,
321            albeit unimplemented, all the attributes of the ndarray class
322            so as to provide a uniform API.
323
324            See Also
325            --------
326            The corresponding attribute of the derived class of interest.
327        """
328        pass
329
330    def max(self, *args, **kwargs):  # real signature unknown
331        """
332        Not implemented (virtual attribute)
333
334            Class generic exists solely to derive numpy scalars from, and possesses,
335            albeit unimplemented, all the attributes of the ndarray class
336            so as to provide a uniform API.
337
338            See Also
339            --------
340            The corresponding attribute of the derived class of interest.
341        """
342        pass
343
344    def mean(self, *args, **kwargs):  # real signature unknown
345        """
346        Not implemented (virtual attribute)
347
348            Class generic exists solely to derive numpy scalars from, and possesses,
349            albeit unimplemented, all the attributes of the ndarray class
350            so as to provide a uniform API.
351
352            See Also
353            --------
354            The corresponding attribute of the derived class of interest.
355        """
356        pass
357
358    def min(self, *args, **kwargs):  # real signature unknown
359        """
360        Not implemented (virtual attribute)
361
362            Class generic exists solely to derive numpy scalars from, and possesses,
363            albeit unimplemented, all the attributes of the ndarray class
364            so as to provide a uniform API.
365
366            See Also
367            --------
368            The corresponding attribute of the derived class of interest.
369        """
370        pass
371
372    def newbyteorder(self, new_order='S'):  # real signature unknown; restored from __doc__
373        """
374        newbyteorder(new_order='S')
375
376            Return a new `dtype` with a different byte order.
377
378            Changes are also made in all fields and sub-arrays of the data type.
379
380            The `new_order` code can be any from the following:
381
382            * 'S' - swap dtype from current to opposite endian
383            * {'<', 'L'} - little endian
384            * {'>', 'B'} - big endian
385            * {'=', 'N'} - native order
386            * {'|', 'I'} - ignore (no change to byte order)
387
388            Parameters
389            ----------
390            new_order : str, optional
391                Byte order to force; a value from the byte order specifications
392                above.  The default value ('S') results in swapping the current
393                byte order. The code does a case-insensitive check on the first
394                letter of `new_order` for the alternatives above.  For example,
395                any of 'B' or 'b' or 'biggish' are valid to specify big-endian.
396
397
398            Returns
399            -------
400            new_dtype : dtype
401                New `dtype` object with the given change to the byte order.
402        """
403        pass
404
405    def nonzero(self, *args, **kwargs):  # real signature unknown
406        """
407        Not implemented (virtual attribute)
408
409            Class generic exists solely to derive numpy scalars from, and possesses,
410            albeit unimplemented, all the attributes of the ndarray class
411            so as to provide a uniform API.
412
413            See Also
414            --------
415            The corresponding attribute of the derived class of interest.
416        """
417        pass
418
419    def prod(self, *args, **kwargs):  # real signature unknown
420        """
421        Not implemented (virtual attribute)
422
423            Class generic exists solely to derive numpy scalars from, and possesses,
424            albeit unimplemented, all the attributes of the ndarray class
425            so as to provide a uniform API.
426
427            See Also
428            --------
429            The corresponding attribute of the derived class of interest.
430        """
431        pass
432
433    def ptp(self, *args, **kwargs):  # real signature unknown
434        """
435        Not implemented (virtual attribute)
436
437            Class generic exists solely to derive numpy scalars from, and possesses,
438            albeit unimplemented, all the attributes of the ndarray class
439            so as to provide a uniform API.
440
441            See Also
442            --------
443            The corresponding attribute of the derived class of interest.
444        """
445        pass
446
447    def put(self, *args, **kwargs):  # real signature unknown
448        """
449        Not implemented (virtual attribute)
450
451            Class generic exists solely to derive numpy scalars from, and possesses,
452            albeit unimplemented, all the attributes of the ndarray class
453            so as to provide a uniform API.
454
455            See Also
456            --------
457            The corresponding attribute of the derived class of interest.
458        """
459        pass
460
461    def ravel(self, *args, **kwargs):  # real signature unknown
462        """
463        Not implemented (virtual attribute)
464
465            Class generic exists solely to derive numpy scalars from, and possesses,
466            albeit unimplemented, all the attributes of the ndarray class
467            so as to provide a uniform API.
468
469            See Also
470            --------
471            The corresponding attribute of the derived class of interest.
472        """
473        pass
474
475    def repeat(self, *args, **kwargs):  # real signature unknown
476        """
477        Not implemented (virtual attribute)
478
479            Class generic exists solely to derive numpy scalars from, and possesses,
480            albeit unimplemented, all the attributes of the ndarray class
481            so as to provide a uniform API.
482
483            See Also
484            --------
485            The corresponding attribute of the derived class of interest.
486        """
487        pass
488
489    def reshape(self, *args, **kwargs):  # real signature unknown
490        """
491        Not implemented (virtual attribute)
492
493            Class generic exists solely to derive numpy scalars from, and possesses,
494            albeit unimplemented, all the attributes of the ndarray class
495            so as to provide a uniform API.
496
497            See Also
498            --------
499            The corresponding attribute of the derived class of interest.
500        """
501        pass
502
503    def resize(self, *args, **kwargs):  # real signature unknown
504        """
505        Not implemented (virtual attribute)
506
507            Class generic exists solely to derive numpy scalars from, and possesses,
508            albeit unimplemented, all the attributes of the ndarray class
509            so as to provide a uniform API.
510
511            See Also
512            --------
513            The corresponding attribute of the derived class of interest.
514        """
515        pass
516
517    def round(self, *args, **kwargs):  # real signature unknown
518        """
519        Not implemented (virtual attribute)
520
521            Class generic exists solely to derive numpy scalars from, and possesses,
522            albeit unimplemented, all the attributes of the ndarray class
523            so as to provide a uniform API.
524
525            See Also
526            --------
527            The corresponding attribute of the derived class of interest.
528        """
529        pass
530
531    def searchsorted(self, *args, **kwargs):  # real signature unknown
532        """
533        Not implemented (virtual attribute)
534
535            Class generic exists solely to derive numpy scalars from, and possesses,
536            albeit unimplemented, all the attributes of the ndarray class
537            so as to provide a uniform API.
538
539            See Also
540            --------
541            The corresponding attribute of the derived class of interest.
542        """
543        pass
544
545    def setfield(self, *args, **kwargs):  # real signature unknown
546        """
547        Not implemented (virtual attribute)
548
549            Class generic exists solely to derive numpy scalars from, and possesses,
550            albeit unimplemented, all the attributes of the ndarray class
551            so as to provide a uniform API.
552
553            See Also
554            --------
555            The corresponding attribute of the derived class of interest.
556        """
557        pass
558
559    def setflags(self, *args, **kwargs):  # real signature unknown
560        """
561        Not implemented (virtual attribute)
562
563            Class generic exists solely to derive numpy scalars from, and possesses,
564            albeit unimplemented, all the attributes of the ndarray class so as to
565            provide a uniform API.
566
567            See Also
568            --------
569            The corresponding attribute of the derived class of interest.
570        """
571        pass
572
573    def sort(self, *args, **kwargs):  # real signature unknown
574        """
575        Not implemented (virtual attribute)
576
577            Class generic exists solely to derive numpy scalars from, and possesses,
578            albeit unimplemented, all the attributes of the ndarray class
579            so as to provide a uniform API.
580
581            See Also
582            --------
583            The corresponding attribute of the derived class of interest.
584        """
585        pass
586
587    def squeeze(self, *args, **kwargs):  # real signature unknown
588        """
589        Not implemented (virtual attribute)
590
591            Class generic exists solely to derive numpy scalars from, and possesses,
592            albeit unimplemented, all the attributes of the ndarray class
593            so as to provide a uniform API.
594
595            See Also
596            --------
597            The corresponding attribute of the derived class of interest.
598        """
599        pass
600
601    def std(self, *args, **kwargs):  # real signature unknown
602        """
603        Not implemented (virtual attribute)
604
605            Class generic exists solely to derive numpy scalars from, and possesses,
606            albeit unimplemented, all the attributes of the ndarray class
607            so as to provide a uniform API.
608
609            See Also
610            --------
611            The corresponding attribute of the derived class of interest.
612        """
613        pass
614
615    def sum(self, *args, **kwargs):  # real signature unknown
616        """
617        Not implemented (virtual attribute)
618
619            Class generic exists solely to derive numpy scalars from, and possesses,
620            albeit unimplemented, all the attributes of the ndarray class
621            so as to provide a uniform API.
622
623            See Also
624            --------
625            The corresponding attribute of the derived class of interest.
626        """
627        pass
628
629    def swapaxes(self, *args, **kwargs):  # real signature unknown
630        """
631        Not implemented (virtual attribute)
632
633            Class generic exists solely to derive numpy scalars from, and possesses,
634            albeit unimplemented, all the attributes of the ndarray class
635            so as to provide a uniform API.
636
637            See Also
638            --------
639            The corresponding attribute of the derived class of interest.
640        """
641        pass
642
643    def take(self, *args, **kwargs):  # real signature unknown
644        """
645        Not implemented (virtual attribute)
646
647            Class generic exists solely to derive numpy scalars from, and possesses,
648            albeit unimplemented, all the attributes of the ndarray class
649            so as to provide a uniform API.
650
651            See Also
652            --------
653            The corresponding attribute of the derived class of interest.
654        """
655        pass
656
657    def tobytes(self, *args, **kwargs):  # real signature unknown
658        pass
659
660    def tofile(self, *args, **kwargs):  # real signature unknown
661        """
662        Not implemented (virtual attribute)
663
664            Class generic exists solely to derive numpy scalars from, and possesses,
665            albeit unimplemented, all the attributes of the ndarray class
666            so as to provide a uniform API.
667
668            See Also
669            --------
670            The corresponding attribute of the derived class of interest.
671        """
672        pass
673
674    def tolist(self, *args, **kwargs):  # real signature unknown
675        """
676        Not implemented (virtual attribute)
677
678            Class generic exists solely to derive numpy scalars from, and possesses,
679            albeit unimplemented, all the attributes of the ndarray class
680            so as to provide a uniform API.
681
682            See Also
683            --------
684            The corresponding attribute of the derived class of interest.
685        """
686        pass
687
688    def tostring(self, *args, **kwargs):  # real signature unknown
689        """
690        Not implemented (virtual attribute)
691
692            Class generic exists solely to derive numpy scalars from, and possesses,
693            albeit unimplemented, all the attributes of the ndarray class
694            so as to provide a uniform API.
695
696            See Also
697            --------
698            The corresponding attribute of the derived class of interest.
699        """
700        pass
701
702    def trace(self, *args, **kwargs):  # real signature unknown
703        """
704        Not implemented (virtual attribute)
705
706            Class generic exists solely to derive numpy scalars from, and possesses,
707            albeit unimplemented, all the attributes of the ndarray class
708            so as to provide a uniform API.
709
710            See Also
711            --------
712            The corresponding attribute of the derived class of interest.
713        """
714        pass
715
716    def transpose(self, *args, **kwargs):  # real signature unknown
717        """
718        Not implemented (virtual attribute)
719
720            Class generic exists solely to derive numpy scalars from, and possesses,
721            albeit unimplemented, all the attributes of the ndarray class
722            so as to provide a uniform API.
723
724            See Also
725            --------
726            The corresponding attribute of the derived class of interest.
727        """
728        pass
729
730    def var(self, *args, **kwargs):  # real signature unknown
731        """
732        Not implemented (virtual attribute)
733
734            Class generic exists solely to derive numpy scalars from, and possesses,
735            albeit unimplemented, all the attributes of the ndarray class
736            so as to provide a uniform API.
737
738            See Also
739            --------
740            The corresponding attribute of the derived class of interest.
741        """
742        pass
743
744    def view(self, *args, **kwargs):  # real signature unknown
745        """
746        Not implemented (virtual attribute)
747
748            Class generic exists solely to derive numpy scalars from, and possesses,
749            albeit unimplemented, all the attributes of the ndarray class
750            so as to provide a uniform API.
751
752            See Also
753            --------
754            The corresponding attribute of the derived class of interest.
755        """
756        pass
757
758    def __abs__(self, *args, **kwargs):  # real signature unknown
759        """ abs(self) """
760        pass
761
762    def __add__(self, *args, **kwargs):  # real signature unknown
763        """ Return self+value. """
764        pass
765
766    def __and__(self, *args, **kwargs):  # real signature unknown
767        """ Return self&value. """
768        pass
769
770    def __array_wrap__(self, obj):  # real signature unknown; restored from __doc__
771        """ sc.__array_wrap__(obj) return scalar from array """
772        pass
773
774    def __array__(self, *args, **kwargs):  # real signature unknown; NOTE: unreliably restored from __doc__
775        """ sc.__array__(|type) return 0-dim array """
776        pass
777
778    def __bool__(self, *args, **kwargs):  # real signature unknown
779        """ self != 0 """
780        pass
781
782    def __copy__(self, *args, **kwargs):  # real signature unknown
783        pass
784
785    def __deepcopy__(self, *args, **kwargs):  # real signature unknown
786        pass
787
788    def __divmod__(self, *args, **kwargs):  # real signature unknown
789        """ Return divmod(self, value). """
790        pass
791
792    def __eq__(self, *args, **kwargs):  # real signature unknown
793        """ Return self==value. """
794        pass
795
796    def __float__(self, *args, **kwargs):  # real signature unknown
797        """ float(self) """
798        pass
799
800    def __floordiv__(self, *args, **kwargs):  # real signature unknown
801        """ Return self//value. """
802        pass
803
804    def __format__(self, *args, **kwargs):  # real signature unknown
805        """ NumPy array scalar formatter """
806        pass
807
808    def __getitem__(self, *args, **kwargs):  # real signature unknown
809        """ Return self[key]. """
810        pass
811
812    def __ge__(self, *args, **kwargs):  # real signature unknown
813        """ Return self>=value. """
814        pass
815
816    def __gt__(self, *args, **kwargs):  # real signature unknown
817        """ Return self>value. """
818        pass
819
820    def __init__(self, *args, **kwargs):  # real signature unknown
821        pass
822
823    def __int__(self, *args, **kwargs):  # real signature unknown
824        """ int(self) """
825        pass
826
827    def __invert__(self, *args, **kwargs):  # real signature unknown
828        """ ~self """
829        pass
830
831    def __le__(self, *args, **kwargs):  # real signature unknown
832        """ Return self<=value. """
833        pass
834
835    def __lshift__(self, *args, **kwargs):  # real signature unknown
836        """ Return self<<value. """
837        pass
838
839    def __lt__(self, *args, **kwargs):  # real signature unknown
840        """ Return self<value. """
841        pass
842
843    def __mod__(self, *args, **kwargs):  # real signature unknown
844        """ Return self%value. """
845        pass
846
847    def __mul__(self, *args, **kwargs):  # real signature unknown
848        """ Return self*value. """
849        pass
850
851    def __neg__(self, *args, **kwargs):  # real signature unknown
852        """ -self """
853        pass
854
855    def __ne__(self, *args, **kwargs):  # real signature unknown
856        """ Return self!=value. """
857        pass
858
859    def __or__(self, *args, **kwargs):  # real signature unknown
860        """ Return self|value. """
861        pass
862
863    def __pos__(self, *args, **kwargs):  # real signature unknown
864        """ +self """
865        pass
866
867    def __pow__(self, *args, **kwargs):  # real signature unknown
868        """ Return pow(self, value, mod). """
869        pass
870
871    def __radd__(self, *args, **kwargs):  # real signature unknown
872        """ Return value+self. """
873        pass
874
875    def __rand__(self, *args, **kwargs):  # real signature unknown
876        """ Return value&self. """
877        pass
878
879    def __rdivmod__(self, *args, **kwargs):  # real signature unknown
880        """ Return divmod(value, self). """
881        pass
882
883    def __reduce__(self, *args, **kwargs):  # real signature unknown
884        pass
885
886    def __repr__(self, *args, **kwargs):  # real signature unknown
887        """ Return repr(self). """
888        pass
889
890    def __rfloordiv__(self, *args, **kwargs):  # real signature unknown
891        """ Return value//self. """
892        pass
893
894    def __rlshift__(self, *args, **kwargs):  # real signature unknown
895        """ Return value<<self. """
896        pass
897
898    def __rmod__(self, *args, **kwargs):  # real signature unknown
899        """ Return value%self. """
900        pass
901
902    def __rmul__(self, *args, **kwargs):  # real signature unknown
903        """ Return value*self. """
904        pass
905
906    def __ror__(self, *args, **kwargs):  # real signature unknown
907        """ Return value|self. """
908        pass
909
910    def __round__(self, *args, **kwargs):  # real signature unknown
911        pass
912
913    def __rpow__(self, *args, **kwargs):  # real signature unknown
914        """ Return pow(value, self, mod). """
915        pass
916
917    def __rrshift__(self, *args, **kwargs):  # real signature unknown
918        """ Return value>>self. """
919        pass
920
921    def __rshift__(self, *args, **kwargs):  # real signature unknown
922        """ Return self>>value. """
923        pass
924
925    def __rsub__(self, *args, **kwargs):  # real signature unknown
926        """ Return value-self. """
927        pass
928
929    def __rtruediv__(self, *args, **kwargs):  # real signature unknown
930        """ Return value/self. """
931        pass
932
933    def __rxor__(self, *args, **kwargs):  # real signature unknown
934        """ Return value^self. """
935        pass
936
937    def __setstate__(self, *args, **kwargs):  # real signature unknown
938        pass
939
940    def __sizeof__(self, *args, **kwargs):  # real signature unknown
941        pass
942
943    def __str__(self, *args, **kwargs):  # real signature unknown
944        """ Return str(self). """
945        pass
946
947    def __sub__(self, *args, **kwargs):  # real signature unknown
948        """ Return self-value. """
949        pass
950
951    def __truediv__(self, *args, **kwargs):  # real signature unknown
952        """ Return self/value. """
953        pass
954
955    def __xor__(self, *args, **kwargs):  # real signature unknown
956        """ Return self^value. """
957        pass
958
959    base = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
960    """base object"""
961
962    data = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
963    """pointer to start of data"""
964
965    dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
966    """get array data-descriptor"""
967
968    flags = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
969    """integer value of flags"""
970
971    flat = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
972    """a 1-d view of scalar"""
973
974    imag = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
975    """imaginary part of scalar"""
976
977    itemsize = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
978    """length of one element in bytes"""
979
980    nbytes = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
981    """length of item in bytes"""
982
983    ndim = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
984    """number of array dimensions"""
985
986    real = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
987    """real part of scalar"""
988
989    shape = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
990    """tuple of array dimensions"""
991
992    size = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
993    """number of elements in the gentype"""
994
995    strides = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
996    """tuple of bytes steps in each dimension"""
997
998    T = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
999    """transpose"""
1000
1001    __array_interface__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1002    """Array protocol: Python side"""
1003
1004    __array_priority__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1005    """Array priority."""
1006
1007    __array_struct__ = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1008    """Array protocol: struct"""
1009
1010    __hash__ = None
1011
1012
1013class bool_(__numpy.generic):
1014    """ NumPy's Boolean type.  Character code: ``?``.  Alias: bool8 """
1015    def __and__(self, *args, **kwargs): # real signature unknown
1016        """ Return self&value. """
1017        pass
1018
1019    def __bool__(self, *args, **kwargs): # real signature unknown
1020        """ self != 0 """
1021        pass
1022
1023    def __eq__(self, *args, **kwargs): # real signature unknown
1024        """ Return self==value. """
1025        pass
1026
1027    def __ge__(self, *args, **kwargs): # real signature unknown
1028        """ Return self>=value. """
1029        pass
1030
1031    def __gt__(self, *args, **kwargs): # real signature unknown
1032        """ Return self>value. """
1033        pass
1034
1035    def __hash__(self, *args, **kwargs): # real signature unknown
1036        """ Return hash(self). """
1037        pass
1038
1039    def __index__(self, *args, **kwargs): # real signature unknown
1040        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
1041        pass
1042
1043    def __init__(self, *args, **kwargs): # real signature unknown
1044        pass
1045
1046    def __le__(self, *args, **kwargs): # real signature unknown
1047        """ Return self<=value. """
1048        pass
1049
1050    def __lt__(self, *args, **kwargs): # real signature unknown
1051        """ Return self<value. """
1052        pass
1053
1054    @staticmethod # known case of __new__
1055    def __new__(*args, **kwargs): # real signature unknown
1056        """ Create and return a new object.  See help(type) for accurate signature. """
1057        pass
1058
1059    def __ne__(self, *args, **kwargs): # real signature unknown
1060        """ Return self!=value. """
1061        pass
1062
1063    def __or__(self, *args, **kwargs): # real signature unknown
1064        """ Return self|value. """
1065        pass
1066
1067    def __rand__(self, *args, **kwargs): # real signature unknown
1068        """ Return value&self. """
1069        pass
1070
1071    def __ror__(self, *args, **kwargs): # real signature unknown
1072        """ Return value|self. """
1073        pass
1074
1075    def __rxor__(self, *args, **kwargs): # real signature unknown
1076        """ Return value^self. """
1077        pass
1078
1079    def __xor__(self, *args, **kwargs): # real signature unknown
1080        """ Return self^value. """
1081        pass
1082
1083
1084bool8 = bool_
1085
1086
1087class number(__numpy.generic):
1088    # no doc
1089    def __init__(self, *args, **kwargs): # real signature unknown
1090        pass
1091
1092
1093class integer(__numpy.number):
1094    # no doc
1095    def __init__(self, *args, **kwargs): # real signature unknown
1096        pass
1097
1098    denominator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1099    """denominator of value (1)"""
1100
1101    numerator = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
1102    """numerator of value (the value itself)"""
1103
1104
1105class signedinteger(__numpy.integer):
1106    # no doc
1107    def __init__(self, *args, **kwargs): # real signature unknown
1108        pass
1109
1110
1111class int8(__numpy.signedinteger):
1112    """ 8-bit integer. Character code ``b``. C char compatible. """
1113    def __abs__(self, *args, **kwargs): # real signature unknown
1114        """ abs(self) """
1115        pass
1116
1117    def __add__(self, *args, **kwargs): # real signature unknown
1118        """ Return self+value. """
1119        pass
1120
1121    def __and__(self, *args, **kwargs): # real signature unknown
1122        """ Return self&value. """
1123        pass
1124
1125    def __bool__(self, *args, **kwargs): # real signature unknown
1126        """ self != 0 """
1127        pass
1128
1129    def __divmod__(self, *args, **kwargs): # real signature unknown
1130        """ Return divmod(self, value). """
1131        pass
1132
1133    def __eq__(self, *args, **kwargs): # real signature unknown
1134        """ Return self==value. """
1135        pass
1136
1137    def __float__(self, *args, **kwargs): # real signature unknown
1138        """ float(self) """
1139        pass
1140
1141    def __floordiv__(self, *args, **kwargs): # real signature unknown
1142        """ Return self//value. """
1143        pass
1144
1145    def __ge__(self, *args, **kwargs): # real signature unknown
1146        """ Return self>=value. """
1147        pass
1148
1149    def __gt__(self, *args, **kwargs): # real signature unknown
1150        """ Return self>value. """
1151        pass
1152
1153    def __hash__(self, *args, **kwargs): # real signature unknown
1154        """ Return hash(self). """
1155        pass
1156
1157    def __index__(self, *args, **kwargs): # real signature unknown
1158        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
1159        pass
1160
1161    def __init__(self, *args, **kwargs): # real signature unknown
1162        pass
1163
1164    def __int__(self, *args, **kwargs): # real signature unknown
1165        """ int(self) """
1166        pass
1167
1168    def __invert__(self, *args, **kwargs): # real signature unknown
1169        """ ~self """
1170        pass
1171
1172    def __le__(self, *args, **kwargs): # real signature unknown
1173        """ Return self<=value. """
1174        pass
1175
1176    def __lshift__(self, *args, **kwargs): # real signature unknown
1177        """ Return self<<value. """
1178        pass
1179
1180    def __lt__(self, *args, **kwargs): # real signature unknown
1181        """ Return self<value. """
1182        pass
1183
1184    def __mod__(self, *args, **kwargs): # real signature unknown
1185        """ Return self%value. """
1186        pass
1187
1188    def __mul__(self, *args, **kwargs): # real signature unknown
1189        """ Return self*value. """
1190        pass
1191
1192    def __neg__(self, *args, **kwargs): # real signature unknown
1193        """ -self """
1194        pass
1195
1196    @staticmethod # known case of __new__
1197    def __new__(*args, **kwargs): # real signature unknown
1198        """ Create and return a new object.  See help(type) for accurate signature. """
1199        pass
1200
1201    def __ne__(self, *args, **kwargs): # real signature unknown
1202        """ Return self!=value. """
1203        pass
1204
1205    def __or__(self, *args, **kwargs): # real signature unknown
1206        """ Return self|value. """
1207        pass
1208
1209    def __pos__(self, *args, **kwargs): # real signature unknown
1210        """ +self """
1211        pass
1212
1213    def __pow__(self, *args, **kwargs): # real signature unknown
1214        """ Return pow(self, value, mod). """
1215        pass
1216
1217    def __radd__(self, *args, **kwargs): # real signature unknown
1218        """ Return value+self. """
1219        pass
1220
1221    def __rand__(self, *args, **kwargs): # real signature unknown
1222        """ Return value&self. """
1223        pass
1224
1225    def __rdivmod__(self, *args, **kwargs): # real signature unknown
1226        """ Return divmod(value, self). """
1227        pass
1228
1229    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
1230        """ Return value//self. """
1231        pass
1232
1233    def __rlshift__(self, *args, **kwargs): # real signature unknown
1234        """ Return value<<self. """
1235        pass
1236
1237    def __rmod__(self, *args, **kwargs): # real signature unknown
1238        """ Return value%self. """
1239        pass
1240
1241    def __rmul__(self, *args, **kwargs): # real signature unknown
1242        """ Return value*self. """
1243        pass
1244
1245    def __ror__(self, *args, **kwargs): # real signature unknown
1246        """ Return value|self. """
1247        pass
1248
1249    def __rpow__(self, *args, **kwargs): # real signature unknown
1250        """ Return pow(value, self, mod). """
1251        pass
1252
1253    def __rrshift__(self, *args, **kwargs): # real signature unknown
1254        """ Return value>>self. """
1255        pass
1256
1257    def __rshift__(self, *args, **kwargs): # real signature unknown
1258        """ Return self>>value. """
1259        pass
1260
1261    def __rsub__(self, *args, **kwargs): # real signature unknown
1262        """ Return value-self. """
1263        pass
1264
1265    def __rtruediv__(self, *args, **kwargs): # real signature unknown
1266        """ Return value/self. """
1267        pass
1268
1269    def __rxor__(self, *args, **kwargs): # real signature unknown
1270        """ Return value^self. """
1271        pass
1272
1273    def __sub__(self, *args, **kwargs): # real signature unknown
1274        """ Return self-value. """
1275        pass
1276
1277    def __truediv__(self, *args, **kwargs): # real signature unknown
1278        """ Return self/value. """
1279        pass
1280
1281    def __xor__(self, *args, **kwargs): # real signature unknown
1282        """ Return self^value. """
1283        pass
1284
1285
1286byte = int8
1287
1288
1289class flexible(__numpy.generic):
1290    # no doc
1291    def __init__(self, *args, **kwargs): # real signature unknown
1292        pass
1293
1294
1295class character(__numpy.flexible):
1296    # no doc
1297    def __init__(self, *args, **kwargs): # real signature unknown
1298        pass
1299
1300class string_(bytes, __numpy.character):
1301    # no doc
1302    def __eq__(self, *args, **kwargs): # real signature unknown
1303        """ Return self==value. """
1304        pass
1305
1306    def __ge__(self, *args, **kwargs): # real signature unknown
1307        """ Return self>=value. """
1308        pass
1309
1310    def __gt__(self, *args, **kwargs): # real signature unknown
1311        """ Return self>value. """
1312        pass
1313
1314    def __hash__(self, *args, **kwargs): # real signature unknown
1315        """ Return hash(self). """
1316        pass
1317
1318    def __init__(self, *args, **kwargs): # real signature unknown
1319        pass
1320
1321    def __le__(self, *args, **kwargs): # real signature unknown
1322        """ Return self<=value. """
1323        pass
1324
1325    def __lt__(self, *args, **kwargs): # real signature unknown
1326        """ Return self<value. """
1327        pass
1328
1329    @staticmethod # known case of __new__
1330    def __new__(*args, **kwargs): # real signature unknown
1331        """ Create and return a new object.  See help(type) for accurate signature. """
1332        pass
1333
1334    def __ne__(self, *args, **kwargs): # real signature unknown
1335        """ Return self!=value. """
1336        pass
1337
1338    def __repr__(self, *args, **kwargs): # real signature unknown
1339        """ Return repr(self). """
1340        pass
1341
1342    def __str__(self, *args, **kwargs): # real signature unknown
1343        """ Return str(self). """
1344        pass
1345
1346
1347bytes_ = string_
1348
1349
1350bytes0 = string_
1351
1352
1353class inexact(number):
1354    # no doc
1355    def __init__(self, *args, **kwargs): # real signature unknown
1356        pass
1357
1358
1359class complexfloating(inexact):
1360    # no doc
1361    def __init__(self, *args, **kwargs): # real signature unknown
1362        pass
1363
1364
1365class complex_(complexfloating, complex):
1366    """ Composed of two 64 bit floats """
1367    def __abs__(self, *args, **kwargs): # real signature unknown
1368        """ abs(self) """
1369        pass
1370
1371    def __add__(self, *args, **kwargs): # real signature unknown
1372        """ Return self+value. """
1373        pass
1374
1375    def __and__(self, *args, **kwargs): # real signature unknown
1376        """ Return self&value. """
1377        pass
1378
1379    def __bool__(self, *args, **kwargs): # real signature unknown
1380        """ self != 0 """
1381        pass
1382
1383    def __divmod__(self, *args, **kwargs): # real signature unknown
1384        """ Return divmod(self, value). """
1385        pass
1386
1387    def __eq__(self, *args, **kwargs): # real signature unknown
1388        """ Return self==value. """
1389        pass
1390
1391    def __float__(self, *args, **kwargs): # real signature unknown
1392        """ float(self) """
1393        pass
1394
1395    def __floordiv__(self, *args, **kwargs): # real signature unknown
1396        """ Return self//value. """
1397        pass
1398
1399    def __ge__(self, *args, **kwargs): # real signature unknown
1400        """ Return self>=value. """
1401        pass
1402
1403    def __gt__(self, *args, **kwargs): # real signature unknown
1404        """ Return self>value. """
1405        pass
1406
1407    def __hash__(self, *args, **kwargs): # real signature unknown
1408        """ Return hash(self). """
1409        pass
1410
1411    def __init__(self, *args, **kwargs): # real signature unknown
1412        pass
1413
1414    def __int__(self, *args, **kwargs): # real signature unknown
1415        """ int(self) """
1416        pass
1417
1418    def __invert__(self, *args, **kwargs): # real signature unknown
1419        """ ~self """
1420        pass
1421
1422    def __le__(self, *args, **kwargs): # real signature unknown
1423        """ Return self<=value. """
1424        pass
1425
1426    def __lshift__(self, *args, **kwargs): # real signature unknown
1427        """ Return self<<value. """
1428        pass
1429
1430    def __lt__(self, *args, **kwargs): # real signature unknown
1431        """ Return self<value. """
1432        pass
1433
1434    def __mod__(self, *args, **kwargs): # real signature unknown
1435        """ Return self%value. """
1436        pass
1437
1438    def __mul__(self, *args, **kwargs): # real signature unknown
1439        """ Return self*value. """
1440        pass
1441
1442    def __neg__(self, *args, **kwargs): # real signature unknown
1443        """ -self """
1444        pass
1445
1446    @staticmethod # known case of __new__
1447    def __new__(*args, **kwargs): # real signature unknown
1448        """ Create and return a new object.  See help(type) for accurate signature. """
1449        pass
1450
1451    def __ne__(self, *args, **kwargs): # real signature unknown
1452        """ Return self!=value. """
1453        pass
1454
1455    def __or__(self, *args, **kwargs): # real signature unknown
1456        """ Return self|value. """
1457        pass
1458
1459    def __pos__(self, *args, **kwargs): # real signature unknown
1460        """ +self """
1461        pass
1462
1463    def __pow__(self, *args, **kwargs): # real signature unknown
1464        """ Return pow(self, value, mod). """
1465        pass
1466
1467    def __radd__(self, *args, **kwargs): # real signature unknown
1468        """ Return value+self. """
1469        pass
1470
1471    def __rand__(self, *args, **kwargs): # real signature unknown
1472        """ Return value&self. """
1473        pass
1474
1475    def __rdivmod__(self, *args, **kwargs): # real signature unknown
1476        """ Return divmod(value, self). """
1477        pass
1478
1479    def __repr__(self, *args, **kwargs): # real signature unknown
1480        """ Return repr(self). """
1481        pass
1482
1483    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
1484        """ Return value//self. """
1485        pass
1486
1487    def __rlshift__(self, *args, **kwargs): # real signature unknown
1488        """ Return value<<self. """
1489        pass
1490
1491    def __rmod__(self, *args, **kwargs): # real signature unknown
1492        """ Return value%self. """
1493        pass
1494
1495    def __rmul__(self, *args, **kwargs): # real signature unknown
1496        """ Return value*self. """
1497        pass
1498
1499    def __ror__(self, *args, **kwargs): # real signature unknown
1500        """ Return value|self. """
1501        pass
1502
1503    def __rpow__(self, *args, **kwargs): # real signature unknown
1504        """ Return pow(value, self, mod). """
1505        pass
1506
1507    def __rrshift__(self, *args, **kwargs): # real signature unknown
1508        """ Return value>>self. """
1509        pass
1510
1511    def __rshift__(self, *args, **kwargs): # real signature unknown
1512        """ Return self>>value. """
1513        pass
1514
1515    def __rsub__(self, *args, **kwargs): # real signature unknown
1516        """ Return value-self. """
1517        pass
1518
1519    def __rtruediv__(self, *args, **kwargs): # real signature unknown
1520        """ Return value/self. """
1521        pass
1522
1523    def __rxor__(self, *args, **kwargs): # real signature unknown
1524        """ Return value^self. """
1525        pass
1526
1527    def __str__(self, *args, **kwargs): # real signature unknown
1528        """ Return str(self). """
1529        pass
1530
1531    def __sub__(self, *args, **kwargs): # real signature unknown
1532        """ Return self-value. """
1533        pass
1534
1535    def __truediv__(self, *args, **kwargs): # real signature unknown
1536        """ Return self/value. """
1537        pass
1538
1539    def __xor__(self, *args, **kwargs): # real signature unknown
1540        """ Return self^value. """
1541        pass
1542
1543complex128 = complex_
1544
1545
1546cfloat = complex_
1547
1548
1549cdouble = complex_
1550
1551
1552class longcomplex(complexfloating):
1553    """ Composed of two 128 bit floats """
1554
1555    def __complex__(self, *args, **kwargs):  # real signature unknown
1556        pass
1557
1558    def __eq__(self, *args, **kwargs):  # real signature unknown
1559        """ Return self==value. """
1560        pass
1561
1562    def __float__(self, *args, **kwargs):  # real signature unknown
1563        """ float(self) """
1564        pass
1565
1566    def __ge__(self, *args, **kwargs):  # real signature unknown
1567        """ Return self>=value. """
1568        pass
1569
1570    def __gt__(self, *args, **kwargs):  # real signature unknown
1571        """ Return self>value. """
1572        pass
1573
1574    def __hash__(self, *args, **kwargs):  # real signature unknown
1575        """ Return hash(self). """
1576        pass
1577
1578    def __init__(self, *args, **kwargs):  # real signature unknown
1579        pass
1580
1581    def __int__(self, *args, **kwargs):  # real signature unknown
1582        """ int(self) """
1583        pass
1584
1585    def __le__(self, *args, **kwargs):  # real signature unknown
1586        """ Return self<=value. """
1587        pass
1588
1589    def __lt__(self, *args, **kwargs):  # real signature unknown
1590        """ Return self<value. """
1591        pass
1592
1593    @staticmethod  # known case of __new__
1594    def __new__(*args, **kwargs):  # real signature unknown
1595        """ Create and return a new object.  See help(type) for accurate signature. """
1596        pass
1597
1598    def __ne__(self, *args, **kwargs):  # real signature unknown
1599        """ Return self!=value. """
1600        pass
1601
1602    def __repr__(self, *args, **kwargs):  # real signature unknown
1603        """ Return repr(self). """
1604        pass
1605
1606    def __str__(self, *args, **kwargs):  # real signature unknown
1607        """ Return str(self). """
1608        pass
1609
1610
1611complex256 = longcomplex
1612
1613clongfloat = longcomplex
1614
1615clongdouble = longcomplex
1616
1617
1618class singlecomplex(complexfloating):
1619    """ Composed of two 32 bit floats """
1620    def __abs__(self, *args, **kwargs): # real signature unknown
1621        """ abs(self) """
1622        pass
1623
1624    def __add__(self, *args, **kwargs): # real signature unknown
1625        """ Return self+value. """
1626        pass
1627
1628    def __and__(self, *args, **kwargs): # real signature unknown
1629        """ Return self&value. """
1630        pass
1631
1632    def __bool__(self, *args, **kwargs): # real signature unknown
1633        """ self != 0 """
1634        pass
1635
1636    def __complex__(self, *args, **kwargs): # real signature unknown
1637        pass
1638
1639    def __divmod__(self, *args, **kwargs): # real signature unknown
1640        """ Return divmod(self, value). """
1641        pass
1642
1643    def __eq__(self, *args, **kwargs): # real signature unknown
1644        """ Return self==value. """
1645        pass
1646
1647    def __float__(self, *args, **kwargs): # real signature unknown
1648        """ float(self) """
1649        pass
1650
1651    def __floordiv__(self, *args, **kwargs): # real signature unknown
1652        """ Return self//value. """
1653        pass
1654
1655    def __ge__(self, *args, **kwargs): # real signature unknown
1656        """ Return self>=value. """
1657        pass
1658
1659    def __gt__(self, *args, **kwargs): # real signature unknown
1660        """ Return self>value. """
1661        pass
1662
1663    def __hash__(self, *args, **kwargs): # real signature unknown
1664        """ Return hash(self). """
1665        pass
1666
1667    def __init__(self, *args, **kwargs): # real signature unknown
1668        pass
1669
1670    def __int__(self, *args, **kwargs): # real signature unknown
1671        """ int(self) """
1672        pass
1673
1674    def __invert__(self, *args, **kwargs): # real signature unknown
1675        """ ~self """
1676        pass
1677
1678    def __le__(self, *args, **kwargs): # real signature unknown
1679        """ Return self<=value. """
1680        pass
1681
1682    def __lshift__(self, *args, **kwargs): # real signature unknown
1683        """ Return self<<value. """
1684        pass
1685
1686    def __lt__(self, *args, **kwargs): # real signature unknown
1687        """ Return self<value. """
1688        pass
1689
1690    def __mod__(self, *args, **kwargs): # real signature unknown
1691        """ Return self%value. """
1692        pass
1693
1694    def __mul__(self, *args, **kwargs): # real signature unknown
1695        """ Return self*value. """
1696        pass
1697
1698    def __neg__(self, *args, **kwargs): # real signature unknown
1699        """ -self """
1700        pass
1701
1702    @staticmethod # known case of __new__
1703    def __new__(*args, **kwargs): # real signature unknown
1704        """ Create and return a new object.  See help(type) for accurate signature. """
1705        pass
1706
1707    def __ne__(self, *args, **kwargs): # real signature unknown
1708        """ Return self!=value. """
1709        pass
1710
1711    def __or__(self, *args, **kwargs): # real signature unknown
1712        """ Return self|value. """
1713        pass
1714
1715    def __pos__(self, *args, **kwargs): # real signature unknown
1716        """ +self """
1717        pass
1718
1719    def __pow__(self, *args, **kwargs): # real signature unknown
1720        """ Return pow(self, value, mod). """
1721        pass
1722
1723    def __radd__(self, *args, **kwargs): # real signature unknown
1724        """ Return value+self. """
1725        pass
1726
1727    def __rand__(self, *args, **kwargs): # real signature unknown
1728        """ Return value&self. """
1729        pass
1730
1731    def __rdivmod__(self, *args, **kwargs): # real signature unknown
1732        """ Return divmod(value, self). """
1733        pass
1734
1735    def __repr__(self, *args, **kwargs): # real signature unknown
1736        """ Return repr(self). """
1737        pass
1738
1739    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
1740        """ Return value//self. """
1741        pass
1742
1743    def __rlshift__(self, *args, **kwargs): # real signature unknown
1744        """ Return value<<self. """
1745        pass
1746
1747    def __rmod__(self, *args, **kwargs): # real signature unknown
1748        """ Return value%self. """
1749        pass
1750
1751    def __rmul__(self, *args, **kwargs): # real signature unknown
1752        """ Return value*self. """
1753        pass
1754
1755    def __ror__(self, *args, **kwargs): # real signature unknown
1756        """ Return value|self. """
1757        pass
1758
1759    def __rpow__(self, *args, **kwargs): # real signature unknown
1760        """ Return pow(value, self, mod). """
1761        pass
1762
1763    def __rrshift__(self, *args, **kwargs): # real signature unknown
1764        """ Return value>>self. """
1765        pass
1766
1767    def __rshift__(self, *args, **kwargs): # real signature unknown
1768        """ Return self>>value. """
1769        pass
1770
1771    def __rsub__(self, *args, **kwargs): # real signature unknown
1772        """ Return value-self. """
1773        pass
1774
1775    def __rtruediv__(self, *args, **kwargs): # real signature unknown
1776        """ Return value/self. """
1777        pass
1778
1779    def __rxor__(self, *args, **kwargs): # real signature unknown
1780        """ Return value^self. """
1781        pass
1782
1783    def __str__(self, *args, **kwargs): # real signature unknown
1784        """ Return str(self). """
1785        pass
1786
1787    def __sub__(self, *args, **kwargs): # real signature unknown
1788        """ Return self-value. """
1789        pass
1790
1791    def __truediv__(self, *args, **kwargs): # real signature unknown
1792        """ Return self/value. """
1793        pass
1794
1795    def __xor__(self, *args, **kwargs): # real signature unknown
1796        """ Return self^value. """
1797        pass
1798
1799
1800csingle = singlecomplex
1801
1802
1803complex64 = singlecomplex
1804
1805
1806class datetime64(generic):
1807    # no doc
1808    def __eq__(self, *args, **kwargs): # real signature unknown
1809        """ Return self==value. """
1810        pass
1811
1812    def __ge__(self, *args, **kwargs): # real signature unknown
1813        """ Return self>=value. """
1814        pass
1815
1816    def __gt__(self, *args, **kwargs): # real signature unknown
1817        """ Return self>value. """
1818        pass
1819
1820    def __hash__(self, *args, **kwargs): # real signature unknown
1821        """ Return hash(self). """
1822        pass
1823
1824    def __init__(self, *args, **kwargs): # real signature unknown
1825        pass
1826
1827    def __le__(self, *args, **kwargs): # real signature unknown
1828        """ Return self<=value. """
1829        pass
1830
1831    def __lt__(self, *args, **kwargs): # real signature unknown
1832        """ Return self<value. """
1833        pass
1834
1835    @staticmethod # known case of __new__
1836    def __new__(*args, **kwargs): # real signature unknown
1837        """ Create and return a new object.  See help(type) for accurate signature. """
1838        pass
1839
1840    def __ne__(self, *args, **kwargs): # real signature unknown
1841        """ Return self!=value. """
1842        pass
1843
1844    def __repr__(self, *args, **kwargs): # real signature unknown
1845        """ Return repr(self). """
1846        pass
1847
1848    def __str__(self, *args, **kwargs): # real signature unknown
1849        """ Return str(self). """
1850        pass
1851
1852
1853class floating(inexact):
1854    # no doc
1855    def __init__(self, *args, **kwargs): # real signature unknown
1856        pass
1857
1858
1859class float_(floating, float):
1860    """ 64-bit floating-point number. Character code 'd'. Python float compatible. """
1861    def __abs__(self, *args, **kwargs): # real signature unknown
1862        """ abs(self) """
1863        pass
1864
1865    def __add__(self, *args, **kwargs): # real signature unknown
1866        """ Return self+value. """
1867        pass
1868
1869    def __and__(self, *args, **kwargs): # real signature unknown
1870        """ Return self&value. """
1871        pass
1872
1873    def __bool__(self, *args, **kwargs): # real signature unknown
1874        """ self != 0 """
1875        pass
1876
1877    def __divmod__(self, *args, **kwargs): # real signature unknown
1878        """ Return divmod(self, value). """
1879        pass
1880
1881    def __eq__(self, *args, **kwargs): # real signature unknown
1882        """ Return self==value. """
1883        pass
1884
1885    def __float__(self, *args, **kwargs): # real signature unknown
1886        """ float(self) """
1887        pass
1888
1889    def __floordiv__(self, *args, **kwargs): # real signature unknown
1890        """ Return self//value. """
1891        pass
1892
1893    def __ge__(self, *args, **kwargs): # real signature unknown
1894        """ Return self>=value. """
1895        pass
1896
1897    def __gt__(self, *args, **kwargs): # real signature unknown
1898        """ Return self>value. """
1899        pass
1900
1901    def __hash__(self, *args, **kwargs): # real signature unknown
1902        """ Return hash(self). """
1903        pass
1904
1905    def __init__(self, *args, **kwargs): # real signature unknown
1906        pass
1907
1908    def __int__(self, *args, **kwargs): # real signature unknown
1909        """ int(self) """
1910        pass
1911
1912    def __invert__(self, *args, **kwargs): # real signature unknown
1913        """ ~self """
1914        pass
1915
1916    def __le__(self, *args, **kwargs): # real signature unknown
1917        """ Return self<=value. """
1918        pass
1919
1920    def __lshift__(self, *args, **kwargs): # real signature unknown
1921        """ Return self<<value. """
1922        pass
1923
1924    def __lt__(self, *args, **kwargs): # real signature unknown
1925        """ Return self<value. """
1926        pass
1927
1928    def __mod__(self, *args, **kwargs): # real signature unknown
1929        """ Return self%value. """
1930        pass
1931
1932    def __mul__(self, *args, **kwargs): # real signature unknown
1933        """ Return self*value. """
1934        pass
1935
1936    def __neg__(self, *args, **kwargs): # real signature unknown
1937        """ -self """
1938        pass
1939
1940    @staticmethod # known case of __new__
1941    def __new__(*args, **kwargs): # real signature unknown
1942        """ Create and return a new object.  See help(type) for accurate signature. """
1943        pass
1944
1945    def __ne__(self, *args, **kwargs): # real signature unknown
1946        """ Return self!=value. """
1947        pass
1948
1949    def __or__(self, *args, **kwargs): # real signature unknown
1950        """ Return self|value. """
1951        pass
1952
1953    def __pos__(self, *args, **kwargs): # real signature unknown
1954        """ +self """
1955        pass
1956
1957    def __pow__(self, *args, **kwargs): # real signature unknown
1958        """ Return pow(self, value, mod). """
1959        pass
1960
1961    def __radd__(self, *args, **kwargs): # real signature unknown
1962        """ Return value+self. """
1963        pass
1964
1965    def __rand__(self, *args, **kwargs): # real signature unknown
1966        """ Return value&self. """
1967        pass
1968
1969    def __rdivmod__(self, *args, **kwargs): # real signature unknown
1970        """ Return divmod(value, self). """
1971        pass
1972
1973    def __repr__(self, *args, **kwargs): # real signature unknown
1974        """ Return repr(self). """
1975        pass
1976
1977    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
1978        """ Return value//self. """
1979        pass
1980
1981    def __rlshift__(self, *args, **kwargs): # real signature unknown
1982        """ Return value<<self. """
1983        pass
1984
1985    def __rmod__(self, *args, **kwargs): # real signature unknown
1986        """ Return value%self. """
1987        pass
1988
1989    def __rmul__(self, *args, **kwargs): # real signature unknown
1990        """ Return value*self. """
1991        pass
1992
1993    def __ror__(self, *args, **kwargs): # real signature unknown
1994        """ Return value|self. """
1995        pass
1996
1997    def __rpow__(self, *args, **kwargs): # real signature unknown
1998        """ Return pow(value, self, mod). """
1999        pass
2000
2001    def __rrshift__(self, *args, **kwargs): # real signature unknown
2002        """ Return value>>self. """
2003        pass
2004
2005    def __rshift__(self, *args, **kwargs): # real signature unknown
2006        """ Return self>>value. """
2007        pass
2008
2009    def __rsub__(self, *args, **kwargs): # real signature unknown
2010        """ Return value-self. """
2011        pass
2012
2013    def __rtruediv__(self, *args, **kwargs): # real signature unknown
2014        """ Return value/self. """
2015        pass
2016
2017    def __rxor__(self, *args, **kwargs): # real signature unknown
2018        """ Return value^self. """
2019        pass
2020
2021    def __str__(self, *args, **kwargs): # real signature unknown
2022        """ Return str(self). """
2023        pass
2024
2025    def __sub__(self, *args, **kwargs): # real signature unknown
2026        """ Return self-value. """
2027        pass
2028
2029    def __truediv__(self, *args, **kwargs): # real signature unknown
2030        """ Return self/value. """
2031        pass
2032
2033    def __xor__(self, *args, **kwargs): # real signature unknown
2034        """ Return self^value. """
2035        pass
2036
2037
2038float64 = float_
2039
2040
2041double = float_
2042
2043
2044class longfloat(floating):
2045    """
2046    128-bit floating-point number. Character code: 'g'. C long float
2047        compatible.
2048    """
2049    def __eq__(self, *args, **kwargs): # real signature unknown
2050        """ Return self==value. """
2051        pass
2052
2053    def __float__(self, *args, **kwargs): # real signature unknown
2054        """ float(self) """
2055        pass
2056
2057    def __ge__(self, *args, **kwargs): # real signature unknown
2058        """ Return self>=value. """
2059        pass
2060
2061    def __gt__(self, *args, **kwargs): # real signature unknown
2062        """ Return self>value. """
2063        pass
2064
2065    def __hash__(self, *args, **kwargs): # real signature unknown
2066        """ Return hash(self). """
2067        pass
2068
2069    def __init__(self, *args, **kwargs): # real signature unknown
2070        pass
2071
2072    def __int__(self, *args, **kwargs): # real signature unknown
2073        """ int(self) """
2074        pass
2075
2076    def __le__(self, *args, **kwargs): # real signature unknown
2077        """ Return self<=value. """
2078        pass
2079
2080    def __lt__(self, *args, **kwargs): # real signature unknown
2081        """ Return self<value. """
2082        pass
2083
2084    @staticmethod # known case of __new__
2085    def __new__(*args, **kwargs): # real signature unknown
2086        """ Create and return a new object.  See help(type) for accurate signature. """
2087        pass
2088
2089    def __ne__(self, *args, **kwargs): # real signature unknown
2090        """ Return self!=value. """
2091        pass
2092
2093    def __repr__(self, *args, **kwargs): # real signature unknown
2094        """ Return repr(self). """
2095        pass
2096
2097    def __str__(self, *args, **kwargs): # real signature unknown
2098        """ Return str(self). """
2099        pass
2100
2101
2102longdouble = longfloat
2103
2104
2105float128 = longfloat
2106
2107
2108class half(floating):
2109    # no doc
2110    def __abs__(self, *args, **kwargs): # real signature unknown
2111        """ abs(self) """
2112        pass
2113
2114    def __add__(self, *args, **kwargs): # real signature unknown
2115        """ Return self+value. """
2116        pass
2117
2118    def __and__(self, *args, **kwargs): # real signature unknown
2119        """ Return self&value. """
2120        pass
2121
2122    def __bool__(self, *args, **kwargs): # real signature unknown
2123        """ self != 0 """
2124        pass
2125
2126    def __divmod__(self, *args, **kwargs): # real signature unknown
2127        """ Return divmod(self, value). """
2128        pass
2129
2130    def __eq__(self, *args, **kwargs): # real signature unknown
2131        """ Return self==value. """
2132        pass
2133
2134    def __float__(self, *args, **kwargs): # real signature unknown
2135        """ float(self) """
2136        pass
2137
2138    def __floordiv__(self, *args, **kwargs): # real signature unknown
2139        """ Return self//value. """
2140        pass
2141
2142    def __ge__(self, *args, **kwargs): # real signature unknown
2143        """ Return self>=value. """
2144        pass
2145
2146    def __gt__(self, *args, **kwargs): # real signature unknown
2147        """ Return self>value. """
2148        pass
2149
2150    def __hash__(self, *args, **kwargs): # real signature unknown
2151        """ Return hash(self). """
2152        pass
2153
2154    def __init__(self, *args, **kwargs): # real signature unknown
2155        pass
2156
2157    def __int__(self, *args, **kwargs): # real signature unknown
2158        """ int(self) """
2159        pass
2160
2161    def __invert__(self, *args, **kwargs): # real signature unknown
2162        """ ~self """
2163        pass
2164
2165    def __le__(self, *args, **kwargs): # real signature unknown
2166        """ Return self<=value. """
2167        pass
2168
2169    def __lshift__(self, *args, **kwargs): # real signature unknown
2170        """ Return self<<value. """
2171        pass
2172
2173    def __lt__(self, *args, **kwargs): # real signature unknown
2174        """ Return self<value. """
2175        pass
2176
2177    def __mod__(self, *args, **kwargs): # real signature unknown
2178        """ Return self%value. """
2179        pass
2180
2181    def __mul__(self, *args, **kwargs): # real signature unknown
2182        """ Return self*value. """
2183        pass
2184
2185    def __neg__(self, *args, **kwargs): # real signature unknown
2186        """ -self """
2187        pass
2188
2189    @staticmethod # known case of __new__
2190    def __new__(*args, **kwargs): # real signature unknown
2191        """ Create and return a new object.  See help(type) for accurate signature. """
2192        pass
2193
2194    def __ne__(self, *args, **kwargs): # real signature unknown
2195        """ Return self!=value. """
2196        pass
2197
2198    def __or__(self, *args, **kwargs): # real signature unknown
2199        """ Return self|value. """
2200        pass
2201
2202    def __pos__(self, *args, **kwargs): # real signature unknown
2203        """ +self """
2204        pass
2205
2206    def __pow__(self, *args, **kwargs): # real signature unknown
2207        """ Return pow(self, value, mod). """
2208        pass
2209
2210    def __radd__(self, *args, **kwargs): # real signature unknown
2211        """ Return value+self. """
2212        pass
2213
2214    def __rand__(self, *args, **kwargs): # real signature unknown
2215        """ Return value&self. """
2216        pass
2217
2218    def __rdivmod__(self, *args, **kwargs): # real signature unknown
2219        """ Return divmod(value, self). """
2220        pass
2221
2222    def __repr__(self, *args, **kwargs): # real signature unknown
2223        """ Return repr(self). """
2224        pass
2225
2226    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
2227        """ Return value//self. """
2228        pass
2229
2230    def __rlshift__(self, *args, **kwargs): # real signature unknown
2231        """ Return value<<self. """
2232        pass
2233
2234    def __rmod__(self, *args, **kwargs): # real signature unknown
2235        """ Return value%self. """
2236        pass
2237
2238    def __rmul__(self, *args, **kwargs): # real signature unknown
2239        """ Return value*self. """
2240        pass
2241
2242    def __ror__(self, *args, **kwargs): # real signature unknown
2243        """ Return value|self. """
2244        pass
2245
2246    def __rpow__(self, *args, **kwargs): # real signature unknown
2247        """ Return pow(value, self, mod). """
2248        pass
2249
2250    def __rrshift__(self, *args, **kwargs): # real signature unknown
2251        """ Return value>>self. """
2252        pass
2253
2254    def __rshift__(self, *args, **kwargs): # real signature unknown
2255        """ Return self>>value. """
2256        pass
2257
2258    def __rsub__(self, *args, **kwargs): # real signature unknown
2259        """ Return value-self. """
2260        pass
2261
2262    def __rtruediv__(self, *args, **kwargs): # real signature unknown
2263        """ Return value/self. """
2264        pass
2265
2266    def __rxor__(self, *args, **kwargs): # real signature unknown
2267        """ Return value^self. """
2268        pass
2269
2270    def __str__(self, *args, **kwargs): # real signature unknown
2271        """ Return str(self). """
2272        pass
2273
2274    def __sub__(self, *args, **kwargs): # real signature unknown
2275        """ Return self-value. """
2276        pass
2277
2278    def __truediv__(self, *args, **kwargs): # real signature unknown
2279        """ Return self/value. """
2280        pass
2281
2282    def __xor__(self, *args, **kwargs): # real signature unknown
2283        """ Return self^value. """
2284        pass
2285
2286
2287float16 = half
2288
2289
2290class single(floating):
2291    """ 32-bit floating-point number. Character code 'f'. C float compatible. """
2292    def __abs__(self, *args, **kwargs): # real signature unknown
2293        """ abs(self) """
2294        pass
2295
2296    def __add__(self, *args, **kwargs): # real signature unknown
2297        """ Return self+value. """
2298        pass
2299
2300    def __and__(self, *args, **kwargs): # real signature unknown
2301        """ Return self&value. """
2302        pass
2303
2304    def __bool__(self, *args, **kwargs): # real signature unknown
2305        """ self != 0 """
2306        pass
2307
2308    def __divmod__(self, *args, **kwargs): # real signature unknown
2309        """ Return divmod(self, value). """
2310        pass
2311
2312    def __eq__(self, *args, **kwargs): # real signature unknown
2313        """ Return self==value. """
2314        pass
2315
2316    def __float__(self, *args, **kwargs): # real signature unknown
2317        """ float(self) """
2318        pass
2319
2320    def __floordiv__(self, *args, **kwargs): # real signature unknown
2321        """ Return self//value. """
2322        pass
2323
2324    def __ge__(self, *args, **kwargs): # real signature unknown
2325        """ Return self>=value. """
2326        pass
2327
2328    def __gt__(self, *args, **kwargs): # real signature unknown
2329        """ Return self>value. """
2330        pass
2331
2332    def __hash__(self, *args, **kwargs): # real signature unknown
2333        """ Return hash(self). """
2334        pass
2335
2336    def __init__(self, *args, **kwargs): # real signature unknown
2337        pass
2338
2339    def __int__(self, *args, **kwargs): # real signature unknown
2340        """ int(self) """
2341        pass
2342
2343    def __invert__(self, *args, **kwargs): # real signature unknown
2344        """ ~self """
2345        pass
2346
2347    def __le__(self, *args, **kwargs): # real signature unknown
2348        """ Return self<=value. """
2349        pass
2350
2351    def __lshift__(self, *args, **kwargs): # real signature unknown
2352        """ Return self<<value. """
2353        pass
2354
2355    def __lt__(self, *args, **kwargs): # real signature unknown
2356        """ Return self<value. """
2357        pass
2358
2359    def __mod__(self, *args, **kwargs): # real signature unknown
2360        """ Return self%value. """
2361        pass
2362
2363    def __mul__(self, *args, **kwargs): # real signature unknown
2364        """ Return self*value. """
2365        pass
2366
2367    def __neg__(self, *args, **kwargs): # real signature unknown
2368        """ -self """
2369        pass
2370
2371    @staticmethod # known case of __new__
2372    def __new__(*args, **kwargs): # real signature unknown
2373        """ Create and return a new object.  See help(type) for accurate signature. """
2374        pass
2375
2376    def __ne__(self, *args, **kwargs): # real signature unknown
2377        """ Return self!=value. """
2378        pass
2379
2380    def __or__(self, *args, **kwargs): # real signature unknown
2381        """ Return self|value. """
2382        pass
2383
2384    def __pos__(self, *args, **kwargs): # real signature unknown
2385        """ +self """
2386        pass
2387
2388    def __pow__(self, *args, **kwargs): # real signature unknown
2389        """ Return pow(self, value, mod). """
2390        pass
2391
2392    def __radd__(self, *args, **kwargs): # real signature unknown
2393        """ Return value+self. """
2394        pass
2395
2396    def __rand__(self, *args, **kwargs): # real signature unknown
2397        """ Return value&self. """
2398        pass
2399
2400    def __rdivmod__(self, *args, **kwargs): # real signature unknown
2401        """ Return divmod(value, self). """
2402        pass
2403
2404    def __repr__(self, *args, **kwargs): # real signature unknown
2405        """ Return repr(self). """
2406        pass
2407
2408    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
2409        """ Return value//self. """
2410        pass
2411
2412    def __rlshift__(self, *args, **kwargs): # real signature unknown
2413        """ Return value<<self. """
2414        pass
2415
2416    def __rmod__(self, *args, **kwargs): # real signature unknown
2417        """ Return value%self. """
2418        pass
2419
2420    def __rmul__(self, *args, **kwargs): # real signature unknown
2421        """ Return value*self. """
2422        pass
2423
2424    def __ror__(self, *args, **kwargs): # real signature unknown
2425        """ Return value|self. """
2426        pass
2427
2428    def __rpow__(self, *args, **kwargs): # real signature unknown
2429        """ Return pow(value, self, mod). """
2430        pass
2431
2432    def __rrshift__(self, *args, **kwargs): # real signature unknown
2433        """ Return value>>self. """
2434        pass
2435
2436    def __rshift__(self, *args, **kwargs): # real signature unknown
2437        """ Return self>>value. """
2438        pass
2439
2440    def __rsub__(self, *args, **kwargs): # real signature unknown
2441        """ Return value-self. """
2442        pass
2443
2444    def __rtruediv__(self, *args, **kwargs): # real signature unknown
2445        """ Return value/self. """
2446        pass
2447
2448    def __rxor__(self, *args, **kwargs): # real signature unknown
2449        """ Return value^self. """
2450        pass
2451
2452    def __str__(self, *args, **kwargs): # real signature unknown
2453        """ Return str(self). """
2454        pass
2455
2456    def __sub__(self, *args, **kwargs): # real signature unknown
2457        """ Return self-value. """
2458        pass
2459
2460    def __truediv__(self, *args, **kwargs): # real signature unknown
2461        """ Return self/value. """
2462        pass
2463
2464    def __xor__(self, *args, **kwargs): # real signature unknown
2465        """ Return self^value. """
2466        pass
2467
2468
2469float32 = single
2470
2471
2472class long(signedinteger):
2473    """ 64-bit integer. Character code 'l'. Python int compatible. """
2474    def __abs__(self, *args, **kwargs): # real signature unknown
2475        """ abs(self) """
2476        pass
2477
2478    def __add__(self, *args, **kwargs): # real signature unknown
2479        """ Return self+value. """
2480        pass
2481
2482    def __and__(self, *args, **kwargs): # real signature unknown
2483        """ Return self&value. """
2484        pass
2485
2486    def __bool__(self, *args, **kwargs): # real signature unknown
2487        """ self != 0 """
2488        pass
2489
2490    def __divmod__(self, *args, **kwargs): # real signature unknown
2491        """ Return divmod(self, value). """
2492        pass
2493
2494    def __eq__(self, *args, **kwargs): # real signature unknown
2495        """ Return self==value. """
2496        pass
2497
2498    def __float__(self, *args, **kwargs): # real signature unknown
2499        """ float(self) """
2500        pass
2501
2502    def __floordiv__(self, *args, **kwargs): # real signature unknown
2503        """ Return self//value. """
2504        pass
2505
2506    def __ge__(self, *args, **kwargs): # real signature unknown
2507        """ Return self>=value. """
2508        pass
2509
2510    def __gt__(self, *args, **kwargs): # real signature unknown
2511        """ Return self>value. """
2512        pass
2513
2514    def __hash__(self, *args, **kwargs): # real signature unknown
2515        """ Return hash(self). """
2516        pass
2517
2518    def __index__(self, *args, **kwargs): # real signature unknown
2519        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
2520        pass
2521
2522    def __init__(self, *args, **kwargs): # real signature unknown
2523        pass
2524
2525    def __int__(self, *args, **kwargs): # real signature unknown
2526        """ int(self) """
2527        pass
2528
2529    def __invert__(self, *args, **kwargs): # real signature unknown
2530        """ ~self """
2531        pass
2532
2533    def __le__(self, *args, **kwargs): # real signature unknown
2534        """ Return self<=value. """
2535        pass
2536
2537    def __lshift__(self, *args, **kwargs): # real signature unknown
2538        """ Return self<<value. """
2539        pass
2540
2541    def __lt__(self, *args, **kwargs): # real signature unknown
2542        """ Return self<value. """
2543        pass
2544
2545    def __mod__(self, *args, **kwargs): # real signature unknown
2546        """ Return self%value. """
2547        pass
2548
2549    def __mul__(self, *args, **kwargs): # real signature unknown
2550        """ Return self*value. """
2551        pass
2552
2553    def __neg__(self, *args, **kwargs): # real signature unknown
2554        """ -self """
2555        pass
2556
2557    @staticmethod # known case of __new__
2558    def __new__(*args, **kwargs): # real signature unknown
2559        """ Create and return a new object.  See help(type) for accurate signature. """
2560        pass
2561
2562    def __ne__(self, *args, **kwargs): # real signature unknown
2563        """ Return self!=value. """
2564        pass
2565
2566    def __or__(self, *args, **kwargs): # real signature unknown
2567        """ Return self|value. """
2568        pass
2569
2570    def __pos__(self, *args, **kwargs): # real signature unknown
2571        """ +self """
2572        pass
2573
2574    def __pow__(self, *args, **kwargs): # real signature unknown
2575        """ Return pow(self, value, mod). """
2576        pass
2577
2578    def __radd__(self, *args, **kwargs): # real signature unknown
2579        """ Return value+self. """
2580        pass
2581
2582    def __rand__(self, *args, **kwargs): # real signature unknown
2583        """ Return value&self. """
2584        pass
2585
2586    def __rdivmod__(self, *args, **kwargs): # real signature unknown
2587        """ Return divmod(value, self). """
2588        pass
2589
2590    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
2591        """ Return value//self. """
2592        pass
2593
2594    def __rlshift__(self, *args, **kwargs): # real signature unknown
2595        """ Return value<<self. """
2596        pass
2597
2598    def __rmod__(self, *args, **kwargs): # real signature unknown
2599        """ Return value%self. """
2600        pass
2601
2602    def __rmul__(self, *args, **kwargs): # real signature unknown
2603        """ Return value*self. """
2604        pass
2605
2606    def __ror__(self, *args, **kwargs): # real signature unknown
2607        """ Return value|self. """
2608        pass
2609
2610    def __rpow__(self, *args, **kwargs): # real signature unknown
2611        """ Return pow(value, self, mod). """
2612        pass
2613
2614    def __rrshift__(self, *args, **kwargs): # real signature unknown
2615        """ Return value>>self. """
2616        pass
2617
2618    def __rshift__(self, *args, **kwargs): # real signature unknown
2619        """ Return self>>value. """
2620        pass
2621
2622    def __rsub__(self, *args, **kwargs): # real signature unknown
2623        """ Return value-self. """
2624        pass
2625
2626    def __rtruediv__(self, *args, **kwargs): # real signature unknown
2627        """ Return value/self. """
2628        pass
2629
2630    def __rxor__(self, *args, **kwargs): # real signature unknown
2631        """ Return value^self. """
2632        pass
2633
2634    def __sub__(self, *args, **kwargs): # real signature unknown
2635        """ Return self-value. """
2636        pass
2637
2638    def __truediv__(self, *args, **kwargs): # real signature unknown
2639        """ Return self/value. """
2640        pass
2641
2642    def __xor__(self, *args, **kwargs): # real signature unknown
2643        """ Return self^value. """
2644        pass
2645
2646
2647int_ = long
2648
2649
2650intp = long
2651
2652
2653int64 = long
2654
2655
2656int0 = long
2657
2658
2659class short(signedinteger):
2660    """ 16-bit integer. Character code ``h``. C short compatible. """
2661    def __abs__(self, *args, **kwargs): # real signature unknown
2662        """ abs(self) """
2663        pass
2664
2665    def __add__(self, *args, **kwargs): # real signature unknown
2666        """ Return self+value. """
2667        pass
2668
2669    def __and__(self, *args, **kwargs): # real signature unknown
2670        """ Return self&value. """
2671        pass
2672
2673    def __bool__(self, *args, **kwargs): # real signature unknown
2674        """ self != 0 """
2675        pass
2676
2677    def __divmod__(self, *args, **kwargs): # real signature unknown
2678        """ Return divmod(self, value). """
2679        pass
2680
2681    def __eq__(self, *args, **kwargs): # real signature unknown
2682        """ Return self==value. """
2683        pass
2684
2685    def __float__(self, *args, **kwargs): # real signature unknown
2686        """ float(self) """
2687        pass
2688
2689    def __floordiv__(self, *args, **kwargs): # real signature unknown
2690        """ Return self//value. """
2691        pass
2692
2693    def __ge__(self, *args, **kwargs): # real signature unknown
2694        """ Return self>=value. """
2695        pass
2696
2697    def __gt__(self, *args, **kwargs): # real signature unknown
2698        """ Return self>value. """
2699        pass
2700
2701    def __hash__(self, *args, **kwargs): # real signature unknown
2702        """ Return hash(self). """
2703        pass
2704
2705    def __index__(self, *args, **kwargs): # real signature unknown
2706        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
2707        pass
2708
2709    def __init__(self, *args, **kwargs): # real signature unknown
2710        pass
2711
2712    def __int__(self, *args, **kwargs): # real signature unknown
2713        """ int(self) """
2714        pass
2715
2716    def __invert__(self, *args, **kwargs): # real signature unknown
2717        """ ~self """
2718        pass
2719
2720    def __le__(self, *args, **kwargs): # real signature unknown
2721        """ Return self<=value. """
2722        pass
2723
2724    def __lshift__(self, *args, **kwargs): # real signature unknown
2725        """ Return self<<value. """
2726        pass
2727
2728    def __lt__(self, *args, **kwargs): # real signature unknown
2729        """ Return self<value. """
2730        pass
2731
2732    def __mod__(self, *args, **kwargs): # real signature unknown
2733        """ Return self%value. """
2734        pass
2735
2736    def __mul__(self, *args, **kwargs): # real signature unknown
2737        """ Return self*value. """
2738        pass
2739
2740    def __neg__(self, *args, **kwargs): # real signature unknown
2741        """ -self """
2742        pass
2743
2744    @staticmethod # known case of __new__
2745    def __new__(*args, **kwargs): # real signature unknown
2746        """ Create and return a new object.  See help(type) for accurate signature. """
2747        pass
2748
2749    def __ne__(self, *args, **kwargs): # real signature unknown
2750        """ Return self!=value. """
2751        pass
2752
2753    def __or__(self, *args, **kwargs): # real signature unknown
2754        """ Return self|value. """
2755        pass
2756
2757    def __pos__(self, *args, **kwargs): # real signature unknown
2758        """ +self """
2759        pass
2760
2761    def __pow__(self, *args, **kwargs): # real signature unknown
2762        """ Return pow(self, value, mod). """
2763        pass
2764
2765    def __radd__(self, *args, **kwargs): # real signature unknown
2766        """ Return value+self. """
2767        pass
2768
2769    def __rand__(self, *args, **kwargs): # real signature unknown
2770        """ Return value&self. """
2771        pass
2772
2773    def __rdivmod__(self, *args, **kwargs): # real signature unknown
2774        """ Return divmod(value, self). """
2775        pass
2776
2777    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
2778        """ Return value//self. """
2779        pass
2780
2781    def __rlshift__(self, *args, **kwargs): # real signature unknown
2782        """ Return value<<self. """
2783        pass
2784
2785    def __rmod__(self, *args, **kwargs): # real signature unknown
2786        """ Return value%self. """
2787        pass
2788
2789    def __rmul__(self, *args, **kwargs): # real signature unknown
2790        """ Return value*self. """
2791        pass
2792
2793    def __ror__(self, *args, **kwargs): # real signature unknown
2794        """ Return value|self. """
2795        pass
2796
2797    def __rpow__(self, *args, **kwargs): # real signature unknown
2798        """ Return pow(value, self, mod). """
2799        pass
2800
2801    def __rrshift__(self, *args, **kwargs): # real signature unknown
2802        """ Return value>>self. """
2803        pass
2804
2805    def __rshift__(self, *args, **kwargs): # real signature unknown
2806        """ Return self>>value. """
2807        pass
2808
2809    def __rsub__(self, *args, **kwargs): # real signature unknown
2810        """ Return value-self. """
2811        pass
2812
2813    def __rtruediv__(self, *args, **kwargs): # real signature unknown
2814        """ Return value/self. """
2815        pass
2816
2817    def __rxor__(self, *args, **kwargs): # real signature unknown
2818        """ Return value^self. """
2819        pass
2820
2821    def __sub__(self, *args, **kwargs): # real signature unknown
2822        """ Return self-value. """
2823        pass
2824
2825    def __truediv__(self, *args, **kwargs): # real signature unknown
2826        """ Return self/value. """
2827        pass
2828
2829    def __xor__(self, *args, **kwargs): # real signature unknown
2830        """ Return self^value. """
2831        pass
2832
2833
2834int16 = short
2835
2836
2837class intc(signedinteger):
2838    """ 32-bit integer. Character code 'i'. C int compatible. """
2839    def __abs__(self, *args, **kwargs): # real signature unknown
2840        """ abs(self) """
2841        pass
2842
2843    def __add__(self, *args, **kwargs): # real signature unknown
2844        """ Return self+value. """
2845        pass
2846
2847    def __and__(self, *args, **kwargs): # real signature unknown
2848        """ Return self&value. """
2849        pass
2850
2851    def __bool__(self, *args, **kwargs): # real signature unknown
2852        """ self != 0 """
2853        pass
2854
2855    def __divmod__(self, *args, **kwargs): # real signature unknown
2856        """ Return divmod(self, value). """
2857        pass
2858
2859    def __eq__(self, *args, **kwargs): # real signature unknown
2860        """ Return self==value. """
2861        pass
2862
2863    def __float__(self, *args, **kwargs): # real signature unknown
2864        """ float(self) """
2865        pass
2866
2867    def __floordiv__(self, *args, **kwargs): # real signature unknown
2868        """ Return self//value. """
2869        pass
2870
2871    def __ge__(self, *args, **kwargs): # real signature unknown
2872        """ Return self>=value. """
2873        pass
2874
2875    def __gt__(self, *args, **kwargs): # real signature unknown
2876        """ Return self>value. """
2877        pass
2878
2879    def __hash__(self, *args, **kwargs): # real signature unknown
2880        """ Return hash(self). """
2881        pass
2882
2883    def __index__(self, *args, **kwargs): # real signature unknown
2884        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
2885        pass
2886
2887    def __init__(self, *args, **kwargs): # real signature unknown
2888        pass
2889
2890    def __int__(self, *args, **kwargs): # real signature unknown
2891        """ int(self) """
2892        pass
2893
2894    def __invert__(self, *args, **kwargs): # real signature unknown
2895        """ ~self """
2896        pass
2897
2898    def __le__(self, *args, **kwargs): # real signature unknown
2899        """ Return self<=value. """
2900        pass
2901
2902    def __lshift__(self, *args, **kwargs): # real signature unknown
2903        """ Return self<<value. """
2904        pass
2905
2906    def __lt__(self, *args, **kwargs): # real signature unknown
2907        """ Return self<value. """
2908        pass
2909
2910    def __mod__(self, *args, **kwargs): # real signature unknown
2911        """ Return self%value. """
2912        pass
2913
2914    def __mul__(self, *args, **kwargs): # real signature unknown
2915        """ Return self*value. """
2916        pass
2917
2918    def __neg__(self, *args, **kwargs): # real signature unknown
2919        """ -self """
2920        pass
2921
2922    @staticmethod # known case of __new__
2923    def __new__(*args, **kwargs): # real signature unknown
2924        """ Create and return a new object.  See help(type) for accurate signature. """
2925        pass
2926
2927    def __ne__(self, *args, **kwargs): # real signature unknown
2928        """ Return self!=value. """
2929        pass
2930
2931    def __or__(self, *args, **kwargs): # real signature unknown
2932        """ Return self|value. """
2933        pass
2934
2935    def __pos__(self, *args, **kwargs): # real signature unknown
2936        """ +self """
2937        pass
2938
2939    def __pow__(self, *args, **kwargs): # real signature unknown
2940        """ Return pow(self, value, mod). """
2941        pass
2942
2943    def __radd__(self, *args, **kwargs): # real signature unknown
2944        """ Return value+self. """
2945        pass
2946
2947    def __rand__(self, *args, **kwargs): # real signature unknown
2948        """ Return value&self. """
2949        pass
2950
2951    def __rdivmod__(self, *args, **kwargs): # real signature unknown
2952        """ Return divmod(value, self). """
2953        pass
2954
2955    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
2956        """ Return value//self. """
2957        pass
2958
2959    def __rlshift__(self, *args, **kwargs): # real signature unknown
2960        """ Return value<<self. """
2961        pass
2962
2963    def __rmod__(self, *args, **kwargs): # real signature unknown
2964        """ Return value%self. """
2965        pass
2966
2967    def __rmul__(self, *args, **kwargs): # real signature unknown
2968        """ Return value*self. """
2969        pass
2970
2971    def __ror__(self, *args, **kwargs): # real signature unknown
2972        """ Return value|self. """
2973        pass
2974
2975    def __rpow__(self, *args, **kwargs): # real signature unknown
2976        """ Return pow(value, self, mod). """
2977        pass
2978
2979    def __rrshift__(self, *args, **kwargs): # real signature unknown
2980        """ Return value>>self. """
2981        pass
2982
2983    def __rshift__(self, *args, **kwargs): # real signature unknown
2984        """ Return self>>value. """
2985        pass
2986
2987    def __rsub__(self, *args, **kwargs): # real signature unknown
2988        """ Return value-self. """
2989        pass
2990
2991    def __rtruediv__(self, *args, **kwargs): # real signature unknown
2992        """ Return value/self. """
2993        pass
2994
2995    def __rxor__(self, *args, **kwargs): # real signature unknown
2996        """ Return value^self. """
2997        pass
2998
2999    def __sub__(self, *args, **kwargs): # real signature unknown
3000        """ Return self-value. """
3001        pass
3002
3003    def __truediv__(self, *args, **kwargs): # real signature unknown
3004        """ Return self/value. """
3005        pass
3006
3007    def __xor__(self, *args, **kwargs): # real signature unknown
3008        """ Return self^value. """
3009        pass
3010
3011
3012int32 = intc
3013
3014
3015class longlong(signedinteger):
3016    # no doc
3017    def __abs__(self, *args, **kwargs): # real signature unknown
3018        """ abs(self) """
3019        pass
3020
3021    def __add__(self, *args, **kwargs): # real signature unknown
3022        """ Return self+value. """
3023        pass
3024
3025    def __and__(self, *args, **kwargs): # real signature unknown
3026        """ Return self&value. """
3027        pass
3028
3029    def __bool__(self, *args, **kwargs): # real signature unknown
3030        """ self != 0 """
3031        pass
3032
3033    def __divmod__(self, *args, **kwargs): # real signature unknown
3034        """ Return divmod(self, value). """
3035        pass
3036
3037    def __eq__(self, *args, **kwargs): # real signature unknown
3038        """ Return self==value. """
3039        pass
3040
3041    def __float__(self, *args, **kwargs): # real signature unknown
3042        """ float(self) """
3043        pass
3044
3045    def __floordiv__(self, *args, **kwargs): # real signature unknown
3046        """ Return self//value. """
3047        pass
3048
3049    def __ge__(self, *args, **kwargs): # real signature unknown
3050        """ Return self>=value. """
3051        pass
3052
3053    def __gt__(self, *args, **kwargs): # real signature unknown
3054        """ Return self>value. """
3055        pass
3056
3057    def __hash__(self, *args, **kwargs): # real signature unknown
3058        """ Return hash(self). """
3059        pass
3060
3061    def __index__(self, *args, **kwargs): # real signature unknown
3062        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
3063        pass
3064
3065    def __init__(self, *args, **kwargs): # real signature unknown
3066        pass
3067
3068    def __int__(self, *args, **kwargs): # real signature unknown
3069        """ int(self) """
3070        pass
3071
3072    def __invert__(self, *args, **kwargs): # real signature unknown
3073        """ ~self """
3074        pass
3075
3076    def __le__(self, *args, **kwargs): # real signature unknown
3077        """ Return self<=value. """
3078        pass
3079
3080    def __lshift__(self, *args, **kwargs): # real signature unknown
3081        """ Return self<<value. """
3082        pass
3083
3084    def __lt__(self, *args, **kwargs): # real signature unknown
3085        """ Return self<value. """
3086        pass
3087
3088    def __mod__(self, *args, **kwargs): # real signature unknown
3089        """ Return self%value. """
3090        pass
3091
3092    def __mul__(self, *args, **kwargs): # real signature unknown
3093        """ Return self*value. """
3094        pass
3095
3096    def __neg__(self, *args, **kwargs): # real signature unknown
3097        """ -self """
3098        pass
3099
3100    @staticmethod # known case of __new__
3101    def __new__(*args, **kwargs): # real signature unknown
3102        """ Create and return a new object.  See help(type) for accurate signature. """
3103        pass
3104
3105    def __ne__(self, *args, **kwargs): # real signature unknown
3106        """ Return self!=value. """
3107        pass
3108
3109    def __or__(self, *args, **kwargs): # real signature unknown
3110        """ Return self|value. """
3111        pass
3112
3113    def __pos__(self, *args, **kwargs): # real signature unknown
3114        """ +self """
3115        pass
3116
3117    def __pow__(self, *args, **kwargs): # real signature unknown
3118        """ Return pow(self, value, mod). """
3119        pass
3120
3121    def __radd__(self, *args, **kwargs): # real signature unknown
3122        """ Return value+self. """
3123        pass
3124
3125    def __rand__(self, *args, **kwargs): # real signature unknown
3126        """ Return value&self. """
3127        pass
3128
3129    def __rdivmod__(self, *args, **kwargs): # real signature unknown
3130        """ Return divmod(value, self). """
3131        pass
3132
3133    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
3134        """ Return value//self. """
3135        pass
3136
3137    def __rlshift__(self, *args, **kwargs): # real signature unknown
3138        """ Return value<<self. """
3139        pass
3140
3141    def __rmod__(self, *args, **kwargs): # real signature unknown
3142        """ Return value%self. """
3143        pass
3144
3145    def __rmul__(self, *args, **kwargs): # real signature unknown
3146        """ Return value*self. """
3147        pass
3148
3149    def __ror__(self, *args, **kwargs): # real signature unknown
3150        """ Return value|self. """
3151        pass
3152
3153    def __rpow__(self, *args, **kwargs): # real signature unknown
3154        """ Return pow(value, self, mod). """
3155        pass
3156
3157    def __rrshift__(self, *args, **kwargs): # real signature unknown
3158        """ Return value>>self. """
3159        pass
3160
3161    def __rshift__(self, *args, **kwargs): # real signature unknown
3162        """ Return self>>value. """
3163        pass
3164
3165    def __rsub__(self, *args, **kwargs): # real signature unknown
3166        """ Return value-self. """
3167        pass
3168
3169    def __rtruediv__(self, *args, **kwargs): # real signature unknown
3170        """ Return value/self. """
3171        pass
3172
3173    def __rxor__(self, *args, **kwargs): # real signature unknown
3174        """ Return value^self. """
3175        pass
3176
3177    def __sub__(self, *args, **kwargs): # real signature unknown
3178        """ Return self-value. """
3179        pass
3180
3181    def __truediv__(self, *args, **kwargs): # real signature unknown
3182        """ Return self/value. """
3183        pass
3184
3185    def __xor__(self, *args, **kwargs): # real signature unknown
3186        """ Return self^value. """
3187        pass
3188
3189
3190class object_(generic):
3191    """ Any Python object.  Character code: 'O'. """
3192    def __add__(self, *args, **kwargs): # real signature unknown
3193        """ Return self+value. """
3194        pass
3195
3196    def __call__(self, *args, **kwargs): # real signature unknown
3197        """ Call self as a function. """
3198        pass
3199
3200    def __contains__(self, *args, **kwargs): # real signature unknown
3201        """ Return key in self. """
3202        pass
3203
3204    def __delattr__(self, *args, **kwargs): # real signature unknown
3205        """ Implement delattr(self, name). """
3206        pass
3207
3208    def __delitem__(self, *args, **kwargs): # real signature unknown
3209        """ Delete self[key]. """
3210        pass
3211
3212    def __eq__(self, *args, **kwargs): # real signature unknown
3213        """ Return self==value. """
3214        pass
3215
3216    def __getattribute__(self, *args, **kwargs): # real signature unknown
3217        """ Return getattr(self, name). """
3218        pass
3219
3220    def __getitem__(self, *args, **kwargs): # real signature unknown
3221        """ Return self[key]. """
3222        pass
3223
3224    def __ge__(self, *args, **kwargs): # real signature unknown
3225        """ Return self>=value. """
3226        pass
3227
3228    def __gt__(self, *args, **kwargs): # real signature unknown
3229        """ Return self>value. """
3230        pass
3231
3232    def __hash__(self, *args, **kwargs): # real signature unknown
3233        """ Return hash(self). """
3234        pass
3235
3236    def __iadd__(self, *args, **kwargs): # real signature unknown
3237        """ Implement self+=value. """
3238        pass
3239
3240    def __imul__(self, *args, **kwargs): # real signature unknown
3241        """ Implement self*=value. """
3242        pass
3243
3244    def __init__(self, *args, **kwargs): # real signature unknown
3245        pass
3246
3247    def __len__(self, *args, **kwargs): # real signature unknown
3248        """ Return len(self). """
3249        pass
3250
3251    def __le__(self, *args, **kwargs): # real signature unknown
3252        """ Return self<=value. """
3253        pass
3254
3255    def __lt__(self, *args, **kwargs): # real signature unknown
3256        """ Return self<value. """
3257        pass
3258
3259    def __mul__(self, *args, **kwargs): # real signature unknown
3260        """ Return self*value.n """
3261        pass
3262
3263    @staticmethod # known case of __new__
3264    def __new__(*args, **kwargs): # real signature unknown
3265        """ Create and return a new object.  See help(type) for accurate signature. """
3266        pass
3267
3268    def __ne__(self, *args, **kwargs): # real signature unknown
3269        """ Return self!=value. """
3270        pass
3271
3272    def __rmul__(self, *args, **kwargs): # real signature unknown
3273        """ Return self*value. """
3274        pass
3275
3276    def __setattr__(self, *args, **kwargs): # real signature unknown
3277        """ Implement setattr(self, name, value). """
3278        pass
3279
3280    def __setitem__(self, *args, **kwargs): # real signature unknown
3281        """ Set self[key] to value. """
3282        pass
3283
3284
3285object0 = object_
3286
3287
3288class void0(flexible):
3289    # no doc
3290    def getfield(self, *args, **kwargs): # real signature unknown
3291        pass
3292
3293    def setfield(self, *args, **kwargs): # real signature unknown
3294        pass
3295
3296    def __delitem__(self, *args, **kwargs): # real signature unknown
3297        """ Delete self[key]. """
3298        pass
3299
3300    def __eq__(self, *args, **kwargs): # real signature unknown
3301        """ Return self==value. """
3302        pass
3303
3304    def __getitem__(self, *args, **kwargs): # real signature unknown
3305        """ Return self[key]. """
3306        pass
3307
3308    def __ge__(self, *args, **kwargs): # real signature unknown
3309        """ Return self>=value. """
3310        pass
3311
3312    def __gt__(self, *args, **kwargs): # real signature unknown
3313        """ Return self>value. """
3314        pass
3315
3316    def __hash__(self, *args, **kwargs): # real signature unknown
3317        """ Return hash(self). """
3318        pass
3319
3320    def __init__(self, *args, **kwargs): # real signature unknown
3321        pass
3322
3323    def __len__(self, *args, **kwargs): # real signature unknown
3324        """ Return len(self). """
3325        pass
3326
3327    def __le__(self, *args, **kwargs): # real signature unknown
3328        """ Return self<=value. """
3329        pass
3330
3331    def __lt__(self, *args, **kwargs): # real signature unknown
3332        """ Return self<value. """
3333        pass
3334
3335    @staticmethod # known case of __new__
3336    def __new__(*args, **kwargs): # real signature unknown
3337        """ Create and return a new object.  See help(type) for accurate signature. """
3338        pass
3339
3340    def __ne__(self, *args, **kwargs): # real signature unknown
3341        """ Return self!=value. """
3342        pass
3343
3344    def __setitem__(self, *args, **kwargs): # real signature unknown
3345        """ Set self[key] to value. """
3346        pass
3347
3348    base = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3349    """base object"""
3350
3351    dtype = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3352    """dtype object"""
3353
3354    flags = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
3355    """integer value of flags"""
3356
3357
3358void = void0
3359
3360
3361class unicode_(str, character):
3362    # no doc
3363    def __eq__(self, *args, **kwargs): # real signature unknown
3364        """ Return self==value. """
3365        pass
3366
3367    def __ge__(self, *args, **kwargs): # real signature unknown
3368        """ Return self>=value. """
3369        pass
3370
3371    def __gt__(self, *args, **kwargs): # real signature unknown
3372        """ Return self>value. """
3373        pass
3374
3375    def __hash__(self, *args, **kwargs): # real signature unknown
3376        """ Return hash(self). """
3377        pass
3378
3379    def __init__(self, *args, **kwargs): # real signature unknown
3380        pass
3381
3382    def __le__(self, *args, **kwargs): # real signature unknown
3383        """ Return self<=value. """
3384        pass
3385
3386    def __lt__(self, *args, **kwargs): # real signature unknown
3387        """ Return self<value. """
3388        pass
3389
3390    @staticmethod # known case of __new__
3391    def __new__(*args, **kwargs): # real signature unknown
3392        """ Create and return a new object.  See help(type) for accurate signature. """
3393        pass
3394
3395    def __ne__(self, *args, **kwargs): # real signature unknown
3396        """ Return self!=value. """
3397        pass
3398
3399    def __repr__(self, *args, **kwargs): # real signature unknown
3400        """ Return repr(self). """
3401        pass
3402
3403    def __str__(self, *args, **kwargs): # real signature unknown
3404        """ Return str(self). """
3405        pass
3406
3407
3408unicode = unicode_
3409
3410
3411str_ = unicode_
3412
3413
3414str0 = unicode_
3415
3416
3417class timedelta64(signedinteger):
3418    # no doc
3419    def __eq__(self, *args, **kwargs): # real signature unknown
3420        """ Return self==value. """
3421        pass
3422
3423    def __ge__(self, *args, **kwargs): # real signature unknown
3424        """ Return self>=value. """
3425        pass
3426
3427    def __gt__(self, *args, **kwargs): # real signature unknown
3428        """ Return self>value. """
3429        pass
3430
3431    def __hash__(self, *args, **kwargs): # real signature unknown
3432        """ Return hash(self). """
3433        pass
3434
3435    def __init__(self, *args, **kwargs): # real signature unknown
3436        pass
3437
3438    def __le__(self, *args, **kwargs): # real signature unknown
3439        """ Return self<=value. """
3440        pass
3441
3442    def __lt__(self, *args, **kwargs): # real signature unknown
3443        """ Return self<value. """
3444        pass
3445
3446    @staticmethod # known case of __new__
3447    def __new__(*args, **kwargs): # real signature unknown
3448        """ Create and return a new object.  See help(type) for accurate signature. """
3449        pass
3450
3451    def __ne__(self, *args, **kwargs): # real signature unknown
3452        """ Return self!=value. """
3453        pass
3454
3455    def __repr__(self, *args, **kwargs): # real signature unknown
3456        """ Return repr(self). """
3457        pass
3458
3459    def __str__(self, *args, **kwargs): # real signature unknown
3460        """ Return str(self). """
3461        pass
3462
3463
3464class unsignedinteger(integer):
3465    # no doc
3466    def __init__(self, *args, **kwargs): # real signature unknown
3467        pass
3468
3469
3470class uint8(unsignedinteger):
3471    # no doc
3472    def __abs__(self, *args, **kwargs): # real signature unknown
3473        """ abs(self) """
3474        pass
3475
3476    def __add__(self, *args, **kwargs): # real signature unknown
3477        """ Return self+value. """
3478        pass
3479
3480    def __and__(self, *args, **kwargs): # real signature unknown
3481        """ Return self&value. """
3482        pass
3483
3484    def __bool__(self, *args, **kwargs): # real signature unknown
3485        """ self != 0 """
3486        pass
3487
3488    def __divmod__(self, *args, **kwargs): # real signature unknown
3489        """ Return divmod(self, value). """
3490        pass
3491
3492    def __eq__(self, *args, **kwargs): # real signature unknown
3493        """ Return self==value. """
3494        pass
3495
3496    def __float__(self, *args, **kwargs): # real signature unknown
3497        """ float(self) """
3498        pass
3499
3500    def __floordiv__(self, *args, **kwargs): # real signature unknown
3501        """ Return self//value. """
3502        pass
3503
3504    def __ge__(self, *args, **kwargs): # real signature unknown
3505        """ Return self>=value. """
3506        pass
3507
3508    def __gt__(self, *args, **kwargs): # real signature unknown
3509        """ Return self>value. """
3510        pass
3511
3512    def __hash__(self, *args, **kwargs): # real signature unknown
3513        """ Return hash(self). """
3514        pass
3515
3516    def __index__(self, *args, **kwargs): # real signature unknown
3517        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
3518        pass
3519
3520    def __init__(self, *args, **kwargs): # real signature unknown
3521        pass
3522
3523    def __int__(self, *args, **kwargs): # real signature unknown
3524        """ int(self) """
3525        pass
3526
3527    def __invert__(self, *args, **kwargs): # real signature unknown
3528        """ ~self """
3529        pass
3530
3531    def __le__(self, *args, **kwargs): # real signature unknown
3532        """ Return self<=value. """
3533        pass
3534
3535    def __lshift__(self, *args, **kwargs): # real signature unknown
3536        """ Return self<<value. """
3537        pass
3538
3539    def __lt__(self, *args, **kwargs): # real signature unknown
3540        """ Return self<value. """
3541        pass
3542
3543    def __mod__(self, *args, **kwargs): # real signature unknown
3544        """ Return self%value. """
3545        pass
3546
3547    def __mul__(self, *args, **kwargs): # real signature unknown
3548        """ Return self*value. """
3549        pass
3550
3551    def __neg__(self, *args, **kwargs): # real signature unknown
3552        """ -self """
3553        pass
3554
3555    @staticmethod # known case of __new__
3556    def __new__(*args, **kwargs): # real signature unknown
3557        """ Create and return a new object.  See help(type) for accurate signature. """
3558        pass
3559
3560    def __ne__(self, *args, **kwargs): # real signature unknown
3561        """ Return self!=value. """
3562        pass
3563
3564    def __or__(self, *args, **kwargs): # real signature unknown
3565        """ Return self|value. """
3566        pass
3567
3568    def __pos__(self, *args, **kwargs): # real signature unknown
3569        """ +self """
3570        pass
3571
3572    def __pow__(self, *args, **kwargs): # real signature unknown
3573        """ Return pow(self, value, mod). """
3574        pass
3575
3576    def __radd__(self, *args, **kwargs): # real signature unknown
3577        """ Return value+self. """
3578        pass
3579
3580    def __rand__(self, *args, **kwargs): # real signature unknown
3581        """ Return value&self. """
3582        pass
3583
3584    def __rdivmod__(self, *args, **kwargs): # real signature unknown
3585        """ Return divmod(value, self). """
3586        pass
3587
3588    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
3589        """ Return value//self. """
3590        pass
3591
3592    def __rlshift__(self, *args, **kwargs): # real signature unknown
3593        """ Return value<<self. """
3594        pass
3595
3596    def __rmod__(self, *args, **kwargs): # real signature unknown
3597        """ Return value%self. """
3598        pass
3599
3600    def __rmul__(self, *args, **kwargs): # real signature unknown
3601        """ Return value*self. """
3602        pass
3603
3604    def __ror__(self, *args, **kwargs): # real signature unknown
3605        """ Return value|self. """
3606        pass
3607
3608    def __rpow__(self, *args, **kwargs): # real signature unknown
3609        """ Return pow(value, self, mod). """
3610        pass
3611
3612    def __rrshift__(self, *args, **kwargs): # real signature unknown
3613        """ Return value>>self. """
3614        pass
3615
3616    def __rshift__(self, *args, **kwargs): # real signature unknown
3617        """ Return self>>value. """
3618        pass
3619
3620    def __rsub__(self, *args, **kwargs): # real signature unknown
3621        """ Return value-self. """
3622        pass
3623
3624    def __rtruediv__(self, *args, **kwargs): # real signature unknown
3625        """ Return value/self. """
3626        pass
3627
3628    def __rxor__(self, *args, **kwargs): # real signature unknown
3629        """ Return value^self. """
3630        pass
3631
3632    def __sub__(self, *args, **kwargs): # real signature unknown
3633        """ Return self-value. """
3634        pass
3635
3636    def __truediv__(self, *args, **kwargs): # real signature unknown
3637        """ Return self/value. """
3638        pass
3639
3640    def __xor__(self, *args, **kwargs): # real signature unknown
3641        """ Return self^value. """
3642        pass
3643
3644
3645ubyte = uint8
3646
3647
3648class ufunc(object):
3649    """
3650    Functions that operate element by element on whole arrays.
3651
3652        To see the documentation for a specific ufunc, use `info`.  For
3653        example, ``np.info(np.sin)``.  Because ufuncs are written in C
3654        (for speed) and linked into Python with NumPy's ufunc facility,
3655        Python's help() function finds this page whenever help() is called
3656        on a ufunc.
3657
3658        A detailed explanation of ufuncs can be found in the docs for :ref:`ufuncs`.
3659
3660        Calling ufuncs:
3661        ===============
3662
3663        op(*x[, out], where=True, **kwargs)
3664        Apply `op` to the arguments `*x` elementwise, broadcasting the arguments.
3665
3666        The broadcasting rules are:
3667
3668        * Dimensions of length 1 may be prepended to either array.
3669        * Arrays may be repeated along dimensions of length 1.
3670
3671        Parameters
3672        ----------
3673        *x : array_like
3674            Input arrays.
3675        out : ndarray, None, or tuple of ndarray and None, optional
3676            Alternate array object(s) in which to put the result; if provided, it
3677            must have a shape that the inputs broadcast to. A tuple of arrays
3678            (possible only as a keyword argument) must have length equal to the
3679            number of outputs; use `None` for outputs to be allocated by the ufunc.
3680        where : array_like, optional
3681            Values of True indicate to calculate the ufunc at that position, values
3682            of False indicate to leave the value in the output alone.
3683        **kwargs
3684            For other keyword-only arguments, see the :ref:`ufunc docs <ufuncs.kwargs>`.
3685
3686        Returns
3687        -------
3688        r : ndarray or tuple of ndarray
3689            `r` will have the shape that the arrays in `x` broadcast to; if `out` is
3690            provided, `r` will be equal to `out`. If the function has more than one
3691            output, then the result will be a tuple of arrays.
3692    """
3693
3694    def accumulate(self, array, axis=0, dtype=None, out=None,
3695                   keepdims=None):  # real signature unknown; restored from __doc__
3696        """
3697        accumulate(array, axis=0, dtype=None, out=None, keepdims=None)
3698
3699            Accumulate the result of applying the operator to all elements.
3700
3701            For a one-dimensional array, accumulate produces results equivalent to::
3702
3703              r = np.empty(len(A))
3704              t = op.identity        # op = the ufunc being applied to A's  elements
3705              for i in range(len(A)):
3706                  t = op(t, A[i])
3707                  r[i] = t
3708              return r
3709
3710            For example, add.accumulate() is equivalent to np.cumsum().
3711
3712            For a multi-dimensional array, accumulate is applied along only one
3713            axis (axis zero by default; see Examples below) so repeated use is
3714            necessary if one wants to accumulate over multiple axes.
3715
3716            Parameters
3717            ----------
3718            array : array_like
3719                The array to act on.
3720            axis : int, optional
3721                The axis along which to apply the accumulation; default is zero.
3722            dtype : data-type code, optional
3723                The data-type used to represent the intermediate results. Defaults
3724                to the data-type of the output array if such is provided, or the
3725                the data-type of the input array if no output array is provided.
3726            out : ndarray, None, or tuple of ndarray and None, optional
3727                A location into which the result is stored. If not provided or `None`,
3728                a freshly-allocated array is returned. For consistency with
3729                :ref:`ufunc.__call__`, if given as a keyword, this may be wrapped in a
3730                1-element tuple.
3731
3732                .. versionchanged:: 1.13.0
3733                   Tuples are allowed for keyword argument.
3734            keepdims : bool
3735                Has no effect. Deprecated, and will be removed in future.
3736
3737            Returns
3738            -------
3739            r : ndarray
3740                The accumulated values. If `out` was supplied, `r` is a reference to
3741                `out`.
3742
3743            Examples
3744            --------
3745            1-D array examples:
3746
3747            >>> np.add.accumulate([2, 3, 5])
3748            array([ 2,  5, 10])
3749            >>> np.multiply.accumulate([2, 3, 5])
3750            array([ 2,  6, 30])
3751
3752            2-D array examples:
3753
3754            >>> I = np.eye(2)
3755            >>> I
3756            array([[ 1.,  0.],
3757                   [ 0.,  1.]])
3758
3759            Accumulate along axis 0 (rows), down columns:
3760
3761            >>> np.add.accumulate(I, 0)
3762            array([[ 1.,  0.],
3763                   [ 1.,  1.]])
3764            >>> np.add.accumulate(I) # no axis specified = axis zero
3765            array([[ 1.,  0.],
3766                   [ 1.,  1.]])
3767
3768            Accumulate along axis 1 (columns), through rows:
3769
3770            >>> np.add.accumulate(I, 1)
3771            array([[ 1.,  1.],
3772                   [ 0.,  1.]])
3773        """
3774        pass
3775
3776    def at(self, a, indices, b=None):  # real signature unknown; restored from __doc__
3777        """
3778        at(a, indices, b=None)
3779
3780            Performs unbuffered in place operation on operand 'a' for elements
3781            specified by 'indices'. For addition ufunc, this method is equivalent to
3782            `a[indices] += b`, except that results are accumulated for elements that
3783            are indexed more than once. For example, `a[[0,0]] += 1` will only
3784            increment the first element once because of buffering, whereas
3785            `add.at(a, [0,0], 1)` will increment the first element twice.
3786
3787            .. versionadded:: 1.8.0
3788
3789            Parameters
3790            ----------
3791            a : array_like
3792                The array to perform in place operation on.
3793            indices : array_like or tuple
3794                Array like index object or slice object for indexing into first
3795                operand. If first operand has multiple dimensions, indices can be a
3796                tuple of array like index objects or slice objects.
3797            b : array_like
3798                Second operand for ufuncs requiring two operands. Operand must be
3799                broadcastable over first operand after indexing or slicing.
3800
3801            Examples
3802            --------
3803            Set items 0 and 1 to their negative values:
3804
3805            >>> a = np.array([1, 2, 3, 4])
3806            >>> np.negative.at(a, [0, 1])
3807            >>> print(a)
3808            array([-1, -2, 3, 4])
3809
3810            ::
3811
3812            Increment items 0 and 1, and increment item 2 twice:
3813
3814            >>> a = np.array([1, 2, 3, 4])
3815            >>> np.add.at(a, [0, 1, 2, 2], 1)
3816            >>> print(a)
3817            array([2, 3, 5, 4])
3818
3819            ::
3820
3821            Add items 0 and 1 in first array to second array,
3822            and store results in first array:
3823
3824            >>> a = np.array([1, 2, 3, 4])
3825            >>> b = np.array([1, 2])
3826            >>> np.add.at(a, [0, 1], b)
3827            >>> print(a)
3828            array([2, 4, 3, 4])
3829        """
3830        pass
3831
3832    def outer(self, A, B, **kwargs):  # real signature unknown; restored from __doc__
3833        """
3834        outer(A, B, **kwargs)
3835
3836            Apply the ufunc `op` to all pairs (a, b) with a in `A` and b in `B`.
3837
3838            Let ``M = A.ndim``, ``N = B.ndim``. Then the result, `C`, of
3839            ``op.outer(A, B)`` is an array of dimension M + N such that:
3840
3841            .. math:: C[i_0, ..., i_{M-1}, j_0, ..., j_{N-1}] =
3842               op(A[i_0, ..., i_{M-1}], B[j_0, ..., j_{N-1}])
3843
3844            For `A` and `B` one-dimensional, this is equivalent to::
3845
3846              r = empty(len(A),len(B))
3847              for i in range(len(A)):
3848                  for j in range(len(B)):
3849                      r[i,j] = op(A[i], B[j]) # op = ufunc in question
3850
3851            Parameters
3852            ----------
3853            A : array_like
3854                First array
3855            B : array_like
3856                Second array
3857            kwargs : any
3858                Arguments to pass on to the ufunc. Typically `dtype` or `out`.
3859
3860            Returns
3861            -------
3862            r : ndarray
3863                Output array
3864
3865            See Also
3866            --------
3867            numpy.outer
3868
3869            Examples
3870            --------
3871            >>> np.multiply.outer([1, 2, 3], [4, 5, 6])
3872            array([[ 4,  5,  6],
3873                   [ 8, 10, 12],
3874                   [12, 15, 18]])
3875
3876            A multi-dimensional example:
3877
3878            >>> A = np.array([[1, 2, 3], [4, 5, 6]])
3879            >>> A.shape
3880            (2, 3)
3881            >>> B = np.array([[1, 2, 3, 4]])
3882            >>> B.shape
3883            (1, 4)
3884            >>> C = np.multiply.outer(A, B)
3885            >>> C.shape; C
3886            (2, 3, 1, 4)
3887            array([[[[ 1,  2,  3,  4]],
3888                    [[ 2,  4,  6,  8]],
3889                    [[ 3,  6,  9, 12]]],
3890                   [[[ 4,  8, 12, 16]],
3891                    [[ 5, 10, 15, 20]],
3892                    [[ 6, 12, 18, 24]]]])
3893        """
3894        pass
3895
3896    def reduce(self, a, axis=0, dtype=None, out=None, keepdims=False):  # real signature unknown; restored from __doc__
3897        """
3898        reduce(a, axis=0, dtype=None, out=None, keepdims=False)
3899
3900            Reduces `a`'s dimension by one, by applying ufunc along one axis.
3901
3902            Let :math:`a.shape = (N_0, ..., N_i, ..., N_{M-1})`.  Then
3903            :math:`ufunc.reduce(a, axis=i)[k_0, ..,k_{i-1}, k_{i+1}, .., k_{M-1}]` =
3904            the result of iterating `j` over :math:`range(N_i)`, cumulatively applying
3905            ufunc to each :math:`a[k_0, ..,k_{i-1}, j, k_{i+1}, .., k_{M-1}]`.
3906            For a one-dimensional array, reduce produces results equivalent to:
3907            ::
3908
3909             r = op.identity # op = ufunc
3910             for i in range(len(A)):
3911               r = op(r, A[i])
3912             return r
3913
3914            For example, add.reduce() is equivalent to sum().
3915
3916            Parameters
3917            ----------
3918            a : array_like
3919                The array to act on.
3920            axis : None or int or tuple of ints, optional
3921                Axis or axes along which a reduction is performed.
3922                The default (`axis` = 0) is perform a reduction over the first
3923                dimension of the input array. `axis` may be negative, in
3924                which case it counts from the last to the first axis.
3925
3926                .. versionadded:: 1.7.0
3927
3928                If this is `None`, a reduction is performed over all the axes.
3929                If this is a tuple of ints, a reduction is performed on multiple
3930                axes, instead of a single axis or all the axes as before.
3931
3932                For operations which are either not commutative or not associative,
3933                doing a reduction over multiple axes is not well-defined. The
3934                ufuncs do not currently raise an exception in this case, but will
3935                likely do so in the future.
3936            dtype : data-type code, optional
3937                The type used to represent the intermediate results. Defaults
3938                to the data-type of the output array if this is provided, or
3939                the data-type of the input array if no output array is provided.
3940            out : ndarray, None, or tuple of ndarray and None, optional
3941                A location into which the result is stored. If not provided or `None`,
3942                a freshly-allocated array is returned. For consistency with
3943                :ref:`ufunc.__call__`, if given as a keyword, this may be wrapped in a
3944                1-element tuple.
3945
3946                .. versionchanged:: 1.13.0
3947                   Tuples are allowed for keyword argument.
3948            keepdims : bool, optional
3949                If this is set to True, the axes which are reduced are left
3950                in the result as dimensions with size one. With this option,
3951                the result will broadcast correctly against the original `arr`.
3952
3953                .. versionadded:: 1.7.0
3954
3955            Returns
3956            -------
3957            r : ndarray
3958                The reduced array. If `out` was supplied, `r` is a reference to it.
3959
3960            Examples
3961            --------
3962            >>> np.multiply.reduce([2,3,5])
3963            30
3964
3965            A multi-dimensional array example:
3966
3967            >>> X = np.arange(8).reshape((2,2,2))
3968            >>> X
3969            array([[[0, 1],
3970                    [2, 3]],
3971                   [[4, 5],
3972                    [6, 7]]])
3973            >>> np.add.reduce(X, 0)
3974            array([[ 4,  6],
3975                   [ 8, 10]])
3976            >>> np.add.reduce(X) # confirm: default axis value is 0
3977            array([[ 4,  6],
3978                   [ 8, 10]])
3979            >>> np.add.reduce(X, 1)
3980            array([[ 2,  4],
3981                   [10, 12]])
3982            >>> np.add.reduce(X, 2)
3983            array([[ 1,  5],
3984                   [ 9, 13]])
3985        """
3986        pass
3987
3988    def reduceat(self, a, indices, axis=0, dtype=None, out=None):  # real signature unknown; restored from __doc__
3989        """
3990        reduceat(a, indices, axis=0, dtype=None, out=None)
3991
3992            Performs a (local) reduce with specified slices over a single axis.
3993
3994            For i in ``range(len(indices))``, `reduceat` computes
3995            ``ufunc.reduce(a[indices[i]:indices[i+1]])``, which becomes the i-th
3996            generalized "row" parallel to `axis` in the final result (i.e., in a
3997            2-D array, for example, if `axis = 0`, it becomes the i-th row, but if
3998            `axis = 1`, it becomes the i-th column).  There are three exceptions to this:
3999
4000            * when ``i = len(indices) - 1`` (so for the last index),
4001              ``indices[i+1] = a.shape[axis]``.
4002            * if ``indices[i] >= indices[i + 1]``, the i-th generalized "row" is
4003              simply ``a[indices[i]]``.
4004            * if ``indices[i] >= len(a)`` or ``indices[i] < 0``, an error is raised.
4005
4006            The shape of the output depends on the size of `indices`, and may be
4007            larger than `a` (this happens if ``len(indices) > a.shape[axis]``).
4008
4009            Parameters
4010            ----------
4011            a : array_like
4012                The array to act on.
4013            indices : array_like
4014                Paired indices, comma separated (not colon), specifying slices to
4015                reduce.
4016            axis : int, optional
4017                The axis along which to apply the reduceat.
4018            dtype : data-type code, optional
4019                The type used to represent the intermediate results. Defaults
4020                to the data type of the output array if this is provided, or
4021                the data type of the input array if no output array is provided.
4022            out : ndarray, None, or tuple of ndarray and None, optional
4023                A location into which the result is stored. If not provided or `None`,
4024                a freshly-allocated array is returned. For consistency with
4025                :ref:`ufunc.__call__`, if given as a keyword, this may be wrapped in a
4026                1-element tuple.
4027
4028                .. versionchanged:: 1.13.0
4029                   Tuples are allowed for keyword argument.
4030
4031            Returns
4032            -------
4033            r : ndarray
4034                The reduced values. If `out` was supplied, `r` is a reference to
4035                `out`.
4036
4037            Notes
4038            -----
4039            A descriptive example:
4040
4041            If `a` is 1-D, the function `ufunc.accumulate(a)` is the same as
4042            ``ufunc.reduceat(a, indices)[::2]`` where `indices` is
4043            ``range(len(array) - 1)`` with a zero placed
4044            in every other element:
4045            ``indices = zeros(2 * len(a) - 1)``, ``indices[1::2] = range(1, len(a))``.
4046
4047            Don't be fooled by this attribute's name: `reduceat(a)` is not
4048            necessarily smaller than `a`.
4049
4050            Examples
4051            --------
4052            To take the running sum of four successive values:
4053
4054            >>> np.add.reduceat(np.arange(8),[0,4, 1,5, 2,6, 3,7])[::2]
4055            array([ 6, 10, 14, 18])
4056
4057            A 2-D example:
4058
4059            >>> x = np.linspace(0, 15, 16).reshape(4,4)
4060            >>> x
4061            array([[  0.,   1.,   2.,   3.],
4062                   [  4.,   5.,   6.,   7.],
4063                   [  8.,   9.,  10.,  11.],
4064                   [ 12.,  13.,  14.,  15.]])
4065
4066            ::
4067
4068             # reduce such that the result has the following five rows:
4069             # [row1 + row2 + row3]
4070             # [row4]
4071             # [row2]
4072             # [row3]
4073             # [row1 + row2 + row3 + row4]
4074
4075            >>> np.add.reduceat(x, [0, 3, 1, 2, 0])
4076            array([[ 12.,  15.,  18.,  21.],
4077                   [ 12.,  13.,  14.,  15.],
4078                   [  4.,   5.,   6.,   7.],
4079                   [  8.,   9.,  10.,  11.],
4080                   [ 24.,  28.,  32.,  36.]])
4081
4082            ::
4083
4084             # reduce such that result has the following two columns:
4085             # [col1 * col2 * col3, col4]
4086
4087            >>> np.multiply.reduceat(x, [0, 3], 1)
4088            array([[    0.,     3.],
4089                   [  120.,     7.],
4090                   [  720.,    11.],
4091                   [ 2184.,    15.]])
4092        """
4093        pass
4094
4095    def __call__(self, *args, **kwargs):  # real signature unknown
4096        """ Call self as a function. """
4097        pass
4098
4099    def __init__(self, *args, **kwargs):  # real signature unknown
4100        pass
4101
4102    def __repr__(self, *args, **kwargs):  # real signature unknown
4103        """ Return repr(self). """
4104        pass
4105
4106    def __str__(self, *args, **kwargs):  # real signature unknown
4107        """ Return str(self). """
4108        pass
4109
4110    identity = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4111    """The identity value.
4112
4113    Data attribute containing the identity element for the ufunc, if it has one.
4114    If it does not, the attribute value is None.
4115
4116    Examples
4117    --------
4118    >>> np.add.identity
4119    0
4120    >>> np.multiply.identity
4121    1
4122    >>> np.power.identity
4123    1
4124    >>> print(np.exp.identity)
4125    None"""
4126
4127    nargs = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4128    """The number of arguments.
4129
4130    Data attribute containing the number of arguments the ufunc takes, including
4131    optional ones.
4132
4133    Notes
4134    -----
4135    Typically this value will be one more than what you might expect because all
4136    ufuncs take  the optional "out" argument.
4137
4138    Examples
4139    --------
4140    >>> np.add.nargs
4141    3
4142    >>> np.multiply.nargs
4143    3
4144    >>> np.power.nargs
4145    3
4146    >>> np.exp.nargs
4147    2"""
4148
4149    nin = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4150    """The number of inputs.
4151
4152    Data attribute containing the number of arguments the ufunc treats as input.
4153
4154    Examples
4155    --------
4156    >>> np.add.nin
4157    2
4158    >>> np.multiply.nin
4159    2
4160    >>> np.power.nin
4161    2
4162    >>> np.exp.nin
4163    1"""
4164
4165    nout = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4166    """The number of outputs.
4167
4168    Data attribute containing the number of arguments the ufunc treats as output.
4169
4170    Notes
4171    -----
4172    Since all ufuncs can take output arguments, this will always be (at least) 1.
4173
4174    Examples
4175    --------
4176    >>> np.add.nout
4177    1
4178    >>> np.multiply.nout
4179    1
4180    >>> np.power.nout
4181    1
4182    >>> np.exp.nout
4183    1"""
4184
4185    ntypes = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4186    """The number of types.
4187
4188    The number of numerical NumPy types - of which there are 18 total - on which
4189    the ufunc can operate.
4190
4191    See Also
4192    --------
4193    numpy.ufunc.types
4194
4195    Examples
4196    --------
4197    >>> np.add.ntypes
4198    18
4199    >>> np.multiply.ntypes
4200    18
4201    >>> np.power.ntypes
4202    17
4203    >>> np.exp.ntypes
4204    7
4205    >>> np.remainder.ntypes
4206    14"""
4207
4208    signature = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4209
4210    types = property(lambda self: object(), lambda self, v: None, lambda self: None)  # default
4211    """Returns a list with types grouped input->output.
4212
4213    Data attribute listing the data-type "Domain-Range" groupings the ufunc can
4214    deliver. The data-types are given using the character codes.
4215
4216    See Also
4217    --------
4218    numpy.ufunc.ntypes
4219
4220    Examples
4221    --------
4222    >>> np.add.types
4223    ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
4224    'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
4225    'GG->G', 'OO->O']
4226
4227    >>> np.multiply.types
4228    ['??->?', 'bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l',
4229    'LL->L', 'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D',
4230    'GG->G', 'OO->O']
4231
4232    >>> np.power.types
4233    ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
4234    'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'FF->F', 'DD->D', 'GG->G',
4235    'OO->O']
4236
4237    >>> np.exp.types
4238    ['f->f', 'd->d', 'g->g', 'F->F', 'D->D', 'G->G', 'O->O']
4239
4240    >>> np.remainder.types
4241    ['bb->b', 'BB->B', 'hh->h', 'HH->H', 'ii->i', 'II->I', 'll->l', 'LL->L',
4242    'qq->q', 'QQ->Q', 'ff->f', 'dd->d', 'gg->g', 'OO->O']"""
4243
4244    __name__ = 'ufunc'
4245
4246
4247class uintp(unsignedinteger):
4248    # no doc
4249    def __abs__(self, *args, **kwargs): # real signature unknown
4250        """ abs(self) """
4251        pass
4252
4253    def __add__(self, *args, **kwargs): # real signature unknown
4254        """ Return self+value. """
4255        pass
4256
4257    def __and__(self, *args, **kwargs): # real signature unknown
4258        """ Return self&value. """
4259        pass
4260
4261    def __bool__(self, *args, **kwargs): # real signature unknown
4262        """ self != 0 """
4263        pass
4264
4265    def __divmod__(self, *args, **kwargs): # real signature unknown
4266        """ Return divmod(self, value). """
4267        pass
4268
4269    def __eq__(self, *args, **kwargs): # real signature unknown
4270        """ Return self==value. """
4271        pass
4272
4273    def __float__(self, *args, **kwargs): # real signature unknown
4274        """ float(self) """
4275        pass
4276
4277    def __floordiv__(self, *args, **kwargs): # real signature unknown
4278        """ Return self//value. """
4279        pass
4280
4281    def __ge__(self, *args, **kwargs): # real signature unknown
4282        """ Return self>=value. """
4283        pass
4284
4285    def __gt__(self, *args, **kwargs): # real signature unknown
4286        """ Return self>value. """
4287        pass
4288
4289    def __hash__(self, *args, **kwargs): # real signature unknown
4290        """ Return hash(self). """
4291        pass
4292
4293    def __index__(self, *args, **kwargs): # real signature unknown
4294        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
4295        pass
4296
4297    def __init__(self, *args, **kwargs): # real signature unknown
4298        pass
4299
4300    def __int__(self, *args, **kwargs): # real signature unknown
4301        """ int(self) """
4302        pass
4303
4304    def __invert__(self, *args, **kwargs): # real signature unknown
4305        """ ~self """
4306        pass
4307
4308    def __le__(self, *args, **kwargs): # real signature unknown
4309        """ Return self<=value. """
4310        pass
4311
4312    def __lshift__(self, *args, **kwargs): # real signature unknown
4313        """ Return self<<value. """
4314        pass
4315
4316    def __lt__(self, *args, **kwargs): # real signature unknown
4317        """ Return self<value. """
4318        pass
4319
4320    def __mod__(self, *args, **kwargs): # real signature unknown
4321        """ Return self%value. """
4322        pass
4323
4324    def __mul__(self, *args, **kwargs): # real signature unknown
4325        """ Return self*value. """
4326        pass
4327
4328    def __neg__(self, *args, **kwargs): # real signature unknown
4329        """ -self """
4330        pass
4331
4332    @staticmethod # known case of __new__
4333    def __new__(*args, **kwargs): # real signature unknown
4334        """ Create and return a new object.  See help(type) for accurate signature. """
4335        pass
4336
4337    def __ne__(self, *args, **kwargs): # real signature unknown
4338        """ Return self!=value. """
4339        pass
4340
4341    def __or__(self, *args, **kwargs): # real signature unknown
4342        """ Return self|value. """
4343        pass
4344
4345    def __pos__(self, *args, **kwargs): # real signature unknown
4346        """ +self """
4347        pass
4348
4349    def __pow__(self, *args, **kwargs): # real signature unknown
4350        """ Return pow(self, value, mod). """
4351        pass
4352
4353    def __radd__(self, *args, **kwargs): # real signature unknown
4354        """ Return value+self. """
4355        pass
4356
4357    def __rand__(self, *args, **kwargs): # real signature unknown
4358        """ Return value&self. """
4359        pass
4360
4361    def __rdivmod__(self, *args, **kwargs): # real signature unknown
4362        """ Return divmod(value, self). """
4363        pass
4364
4365    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
4366        """ Return value//self. """
4367        pass
4368
4369    def __rlshift__(self, *args, **kwargs): # real signature unknown
4370        """ Return value<<self. """
4371        pass
4372
4373    def __rmod__(self, *args, **kwargs): # real signature unknown
4374        """ Return value%self. """
4375        pass
4376
4377    def __rmul__(self, *args, **kwargs): # real signature unknown
4378        """ Return value*self. """
4379        pass
4380
4381    def __ror__(self, *args, **kwargs): # real signature unknown
4382        """ Return value|self. """
4383        pass
4384
4385    def __rpow__(self, *args, **kwargs): # real signature unknown
4386        """ Return pow(value, self, mod). """
4387        pass
4388
4389    def __rrshift__(self, *args, **kwargs): # real signature unknown
4390        """ Return value>>self. """
4391        pass
4392
4393    def __rshift__(self, *args, **kwargs): # real signature unknown
4394        """ Return self>>value. """
4395        pass
4396
4397    def __rsub__(self, *args, **kwargs): # real signature unknown
4398        """ Return value-self. """
4399        pass
4400
4401    def __rtruediv__(self, *args, **kwargs): # real signature unknown
4402        """ Return value/self. """
4403        pass
4404
4405    def __rxor__(self, *args, **kwargs): # real signature unknown
4406        """ Return value^self. """
4407        pass
4408
4409    def __sub__(self, *args, **kwargs): # real signature unknown
4410        """ Return self-value. """
4411        pass
4412
4413    def __truediv__(self, *args, **kwargs): # real signature unknown
4414        """ Return self/value. """
4415        pass
4416
4417    def __xor__(self, *args, **kwargs): # real signature unknown
4418        """ Return self^value. """
4419        pass
4420
4421
4422uint64 = uintp
4423
4424
4425uint0 = uintp
4426
4427
4428uint = uintp
4429
4430
4431class ushort(unsignedinteger):
4432    # no doc
4433    def __abs__(self, *args, **kwargs): # real signature unknown
4434        """ abs(self) """
4435        pass
4436
4437    def __add__(self, *args, **kwargs): # real signature unknown
4438        """ Return self+value. """
4439        pass
4440
4441    def __and__(self, *args, **kwargs): # real signature unknown
4442        """ Return self&value. """
4443        pass
4444
4445    def __bool__(self, *args, **kwargs): # real signature unknown
4446        """ self != 0 """
4447        pass
4448
4449    def __divmod__(self, *args, **kwargs): # real signature unknown
4450        """ Return divmod(self, value). """
4451        pass
4452
4453    def __eq__(self, *args, **kwargs): # real signature unknown
4454        """ Return self==value. """
4455        pass
4456
4457    def __float__(self, *args, **kwargs): # real signature unknown
4458        """ float(self) """
4459        pass
4460
4461    def __floordiv__(self, *args, **kwargs): # real signature unknown
4462        """ Return self//value. """
4463        pass
4464
4465    def __ge__(self, *args, **kwargs): # real signature unknown
4466        """ Return self>=value. """
4467        pass
4468
4469    def __gt__(self, *args, **kwargs): # real signature unknown
4470        """ Return self>value. """
4471        pass
4472
4473    def __hash__(self, *args, **kwargs): # real signature unknown
4474        """ Return hash(self). """
4475        pass
4476
4477    def __index__(self, *args, **kwargs): # real signature unknown
4478        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
4479        pass
4480
4481    def __init__(self, *args, **kwargs): # real signature unknown
4482        pass
4483
4484    def __int__(self, *args, **kwargs): # real signature unknown
4485        """ int(self) """
4486        pass
4487
4488    def __invert__(self, *args, **kwargs): # real signature unknown
4489        """ ~self """
4490        pass
4491
4492    def __le__(self, *args, **kwargs): # real signature unknown
4493        """ Return self<=value. """
4494        pass
4495
4496    def __lshift__(self, *args, **kwargs): # real signature unknown
4497        """ Return self<<value. """
4498        pass
4499
4500    def __lt__(self, *args, **kwargs): # real signature unknown
4501        """ Return self<value. """
4502        pass
4503
4504    def __mod__(self, *args, **kwargs): # real signature unknown
4505        """ Return self%value. """
4506        pass
4507
4508    def __mul__(self, *args, **kwargs): # real signature unknown
4509        """ Return self*value. """
4510        pass
4511
4512    def __neg__(self, *args, **kwargs): # real signature unknown
4513        """ -self """
4514        pass
4515
4516    @staticmethod # known case of __new__
4517    def __new__(*args, **kwargs): # real signature unknown
4518        """ Create and return a new object.  See help(type) for accurate signature. """
4519        pass
4520
4521    def __ne__(self, *args, **kwargs): # real signature unknown
4522        """ Return self!=value. """
4523        pass
4524
4525    def __or__(self, *args, **kwargs): # real signature unknown
4526        """ Return self|value. """
4527        pass
4528
4529    def __pos__(self, *args, **kwargs): # real signature unknown
4530        """ +self """
4531        pass
4532
4533    def __pow__(self, *args, **kwargs): # real signature unknown
4534        """ Return pow(self, value, mod). """
4535        pass
4536
4537    def __radd__(self, *args, **kwargs): # real signature unknown
4538        """ Return value+self. """
4539        pass
4540
4541    def __rand__(self, *args, **kwargs): # real signature unknown
4542        """ Return value&self. """
4543        pass
4544
4545    def __rdivmod__(self, *args, **kwargs): # real signature unknown
4546        """ Return divmod(value, self). """
4547        pass
4548
4549    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
4550        """ Return value//self. """
4551        pass
4552
4553    def __rlshift__(self, *args, **kwargs): # real signature unknown
4554        """ Return value<<self. """
4555        pass
4556
4557    def __rmod__(self, *args, **kwargs): # real signature unknown
4558        """ Return value%self. """
4559        pass
4560
4561    def __rmul__(self, *args, **kwargs): # real signature unknown
4562        """ Return value*self. """
4563        pass
4564
4565    def __ror__(self, *args, **kwargs): # real signature unknown
4566        """ Return value|self. """
4567        pass
4568
4569    def __rpow__(self, *args, **kwargs): # real signature unknown
4570        """ Return pow(value, self, mod). """
4571        pass
4572
4573    def __rrshift__(self, *args, **kwargs): # real signature unknown
4574        """ Return value>>self. """
4575        pass
4576
4577    def __rshift__(self, *args, **kwargs): # real signature unknown
4578        """ Return self>>value. """
4579        pass
4580
4581    def __rsub__(self, *args, **kwargs): # real signature unknown
4582        """ Return value-self. """
4583        pass
4584
4585    def __rtruediv__(self, *args, **kwargs): # real signature unknown
4586        """ Return value/self. """
4587        pass
4588
4589    def __rxor__(self, *args, **kwargs): # real signature unknown
4590        """ Return value^self. """
4591        pass
4592
4593    def __sub__(self, *args, **kwargs): # real signature unknown
4594        """ Return self-value. """
4595        pass
4596
4597    def __truediv__(self, *args, **kwargs): # real signature unknown
4598        """ Return self/value. """
4599        pass
4600
4601    def __xor__(self, *args, **kwargs): # real signature unknown
4602        """ Return self^value. """
4603        pass
4604
4605
4606uint16 = ushort
4607
4608
4609class uintc(unsignedinteger):
4610    # no doc
4611    def __abs__(self, *args, **kwargs): # real signature unknown
4612        """ abs(self) """
4613        pass
4614
4615    def __add__(self, *args, **kwargs): # real signature unknown
4616        """ Return self+value. """
4617        pass
4618
4619    def __and__(self, *args, **kwargs): # real signature unknown
4620        """ Return self&value. """
4621        pass
4622
4623    def __bool__(self, *args, **kwargs): # real signature unknown
4624        """ self != 0 """
4625        pass
4626
4627    def __divmod__(self, *args, **kwargs): # real signature unknown
4628        """ Return divmod(self, value). """
4629        pass
4630
4631    def __eq__(self, *args, **kwargs): # real signature unknown
4632        """ Return self==value. """
4633        pass
4634
4635    def __float__(self, *args, **kwargs): # real signature unknown
4636        """ float(self) """
4637        pass
4638
4639    def __floordiv__(self, *args, **kwargs): # real signature unknown
4640        """ Return self//value. """
4641        pass
4642
4643    def __ge__(self, *args, **kwargs): # real signature unknown
4644        """ Return self>=value. """
4645        pass
4646
4647    def __gt__(self, *args, **kwargs): # real signature unknown
4648        """ Return self>value. """
4649        pass
4650
4651    def __hash__(self, *args, **kwargs): # real signature unknown
4652        """ Return hash(self). """
4653        pass
4654
4655    def __index__(self, *args, **kwargs): # real signature unknown
4656        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
4657        pass
4658
4659    def __init__(self, *args, **kwargs): # real signature unknown
4660        pass
4661
4662    def __int__(self, *args, **kwargs): # real signature unknown
4663        """ int(self) """
4664        pass
4665
4666    def __invert__(self, *args, **kwargs): # real signature unknown
4667        """ ~self """
4668        pass
4669
4670    def __le__(self, *args, **kwargs): # real signature unknown
4671        """ Return self<=value. """
4672        pass
4673
4674    def __lshift__(self, *args, **kwargs): # real signature unknown
4675        """ Return self<<value. """
4676        pass
4677
4678    def __lt__(self, *args, **kwargs): # real signature unknown
4679        """ Return self<value. """
4680        pass
4681
4682    def __mod__(self, *args, **kwargs): # real signature unknown
4683        """ Return self%value. """
4684        pass
4685
4686    def __mul__(self, *args, **kwargs): # real signature unknown
4687        """ Return self*value. """
4688        pass
4689
4690    def __neg__(self, *args, **kwargs): # real signature unknown
4691        """ -self """
4692        pass
4693
4694    @staticmethod # known case of __new__
4695    def __new__(*args, **kwargs): # real signature unknown
4696        """ Create and return a new object.  See help(type) for accurate signature. """
4697        pass
4698
4699    def __ne__(self, *args, **kwargs): # real signature unknown
4700        """ Return self!=value. """
4701        pass
4702
4703    def __or__(self, *args, **kwargs): # real signature unknown
4704        """ Return self|value. """
4705        pass
4706
4707    def __pos__(self, *args, **kwargs): # real signature unknown
4708        """ +self """
4709        pass
4710
4711    def __pow__(self, *args, **kwargs): # real signature unknown
4712        """ Return pow(self, value, mod). """
4713        pass
4714
4715    def __radd__(self, *args, **kwargs): # real signature unknown
4716        """ Return value+self. """
4717        pass
4718
4719    def __rand__(self, *args, **kwargs): # real signature unknown
4720        """ Return value&self. """
4721        pass
4722
4723    def __rdivmod__(self, *args, **kwargs): # real signature unknown
4724        """ Return divmod(value, self). """
4725        pass
4726
4727    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
4728        """ Return value//self. """
4729        pass
4730
4731    def __rlshift__(self, *args, **kwargs): # real signature unknown
4732        """ Return value<<self. """
4733        pass
4734
4735    def __rmod__(self, *args, **kwargs): # real signature unknown
4736        """ Return value%self. """
4737        pass
4738
4739    def __rmul__(self, *args, **kwargs): # real signature unknown
4740        """ Return value*self. """
4741        pass
4742
4743    def __ror__(self, *args, **kwargs): # real signature unknown
4744        """ Return value|self. """
4745        pass
4746
4747    def __rpow__(self, *args, **kwargs): # real signature unknown
4748        """ Return pow(value, self, mod). """
4749        pass
4750
4751    def __rrshift__(self, *args, **kwargs): # real signature unknown
4752        """ Return value>>self. """
4753        pass
4754
4755    def __rshift__(self, *args, **kwargs): # real signature unknown
4756        """ Return self>>value. """
4757        pass
4758
4759    def __rsub__(self, *args, **kwargs): # real signature unknown
4760        """ Return value-self. """
4761        pass
4762
4763    def __rtruediv__(self, *args, **kwargs): # real signature unknown
4764        """ Return value/self. """
4765        pass
4766
4767    def __rxor__(self, *args, **kwargs): # real signature unknown
4768        """ Return value^self. """
4769        pass
4770
4771    def __sub__(self, *args, **kwargs): # real signature unknown
4772        """ Return self-value. """
4773        pass
4774
4775    def __truediv__(self, *args, **kwargs): # real signature unknown
4776        """ Return self/value. """
4777        pass
4778
4779    def __xor__(self, *args, **kwargs): # real signature unknown
4780        """ Return self^value. """
4781        pass
4782
4783
4784uint32 = uintc
4785
4786
4787class ulonglong(unsignedinteger):
4788    # no doc
4789    def __abs__(self, *args, **kwargs): # real signature unknown
4790        """ abs(self) """
4791        pass
4792
4793    def __add__(self, *args, **kwargs): # real signature unknown
4794        """ Return self+value. """
4795        pass
4796
4797    def __and__(self, *args, **kwargs): # real signature unknown
4798        """ Return self&value. """
4799        pass
4800
4801    def __bool__(self, *args, **kwargs): # real signature unknown
4802        """ self != 0 """
4803        pass
4804
4805    def __divmod__(self, *args, **kwargs): # real signature unknown
4806        """ Return divmod(self, value). """
4807        pass
4808
4809    def __eq__(self, *args, **kwargs): # real signature unknown
4810        """ Return self==value. """
4811        pass
4812
4813    def __float__(self, *args, **kwargs): # real signature unknown
4814        """ float(self) """
4815        pass
4816
4817    def __floordiv__(self, *args, **kwargs): # real signature unknown
4818        """ Return self//value. """
4819        pass
4820
4821    def __ge__(self, *args, **kwargs): # real signature unknown
4822        """ Return self>=value. """
4823        pass
4824
4825    def __gt__(self, *args, **kwargs): # real signature unknown
4826        """ Return self>value. """
4827        pass
4828
4829    def __hash__(self, *args, **kwargs): # real signature unknown
4830        """ Return hash(self). """
4831        pass
4832
4833    def __index__(self, *args, **kwargs): # real signature unknown
4834        """ Return self converted to an integer, if self is suitable for use as an index into a list. """
4835        pass
4836
4837    def __init__(self, *args, **kwargs): # real signature unknown
4838        pass
4839
4840    def __int__(self, *args, **kwargs): # real signature unknown
4841        """ int(self) """
4842        pass
4843
4844    def __invert__(self, *args, **kwargs): # real signature unknown
4845        """ ~self """
4846        pass
4847
4848    def __le__(self, *args, **kwargs): # real signature unknown
4849        """ Return self<=value. """
4850        pass
4851
4852    def __lshift__(self, *args, **kwargs): # real signature unknown
4853        """ Return self<<value. """
4854        pass
4855
4856    def __lt__(self, *args, **kwargs): # real signature unknown
4857        """ Return self<value. """
4858        pass
4859
4860    def __mod__(self, *args, **kwargs): # real signature unknown
4861        """ Return self%value. """
4862        pass
4863
4864    def __mul__(self, *args, **kwargs): # real signature unknown
4865        """ Return self*value. """
4866        pass
4867
4868    def __neg__(self, *args, **kwargs): # real signature unknown
4869        """ -self """
4870        pass
4871
4872    @staticmethod # known case of __new__
4873    def __new__(*args, **kwargs): # real signature unknown
4874        """ Create and return a new object.  See help(type) for accurate signature. """
4875        pass
4876
4877    def __ne__(self, *args, **kwargs): # real signature unknown
4878        """ Return self!=value. """
4879        pass
4880
4881    def __or__(self, *args, **kwargs): # real signature unknown
4882        """ Return self|value. """
4883        pass
4884
4885    def __pos__(self, *args, **kwargs): # real signature unknown
4886        """ +self """
4887        pass
4888
4889    def __pow__(self, *args, **kwargs): # real signature unknown
4890        """ Return pow(self, value, mod). """
4891        pass
4892
4893    def __radd__(self, *args, **kwargs): # real signature unknown
4894        """ Return value+self. """
4895        pass
4896
4897    def __rand__(self, *args, **kwargs): # real signature unknown
4898        """ Return value&self. """
4899        pass
4900
4901    def __rdivmod__(self, *args, **kwargs): # real signature unknown
4902        """ Return divmod(value, self). """
4903        pass
4904
4905    def __rfloordiv__(self, *args, **kwargs): # real signature unknown
4906        """ Return value//self. """
4907        pass
4908
4909    def __rlshift__(self, *args, **kwargs): # real signature unknown
4910        """ Return value<<self. """
4911        pass
4912
4913    def __rmod__(self, *args, **kwargs): # real signature unknown
4914        """ Return value%self. """
4915        pass
4916
4917    def __rmul__(self, *args, **kwargs): # real signature unknown
4918        """ Return value*self. """
4919        pass
4920
4921    def __ror__(self, *args, **kwargs): # real signature unknown
4922        """ Return value|self. """
4923        pass
4924
4925    def __rpow__(self, *args, **kwargs): # real signature unknown
4926        """ Return pow(value, self, mod). """
4927        pass
4928
4929    def __rrshift__(self, *args, **kwargs): # real signature unknown
4930        """ Return value>>self. """
4931        pass
4932
4933    def __rshift__(self, *args, **kwargs): # real signature unknown
4934        """ Return self>>value. """
4935        pass
4936
4937    def __rsub__(self, *args, **kwargs): # real signature unknown
4938        """ Return value-self. """
4939        pass
4940
4941    def __rtruediv__(self, *args, **kwargs): # real signature unknown
4942        """ Return value/self. """
4943        pass
4944
4945    def __rxor__(self, *args, **kwargs): # real signature unknown
4946        """ Return value^self. """
4947        pass
4948
4949    def __sub__(self, *args, **kwargs): # real signature unknown
4950        """ Return self-value. """
4951        pass
4952
4953    def __truediv__(self, *args, **kwargs): # real signature unknown
4954        """ Return self/value. """
4955        pass
4956
4957    def __xor__(self, *args, **kwargs): # real signature unknown
4958        """ Return self^value. """
4959        pass
4960