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