src/ieee754/part/util.pyi

   1 # SPDX-License-Identifier: LGPL-3-or-later
   2 # See Notices.txt for copyright information
   3
   4 from enum import Enum
   5 from typing import (Any, Callable, ClassVar, Generic, ItemsView, Iterable,
   6                     Iterator, KeysView, Literal, Mapping, Optional, Tuple,
   7                     TypeVar, Union, ValuesView, overload)
   8
   9
  10 class ElWid(Enum):
  11     def __repr__(self) -> str: ...
  12
  13
  14 class FpElWid(ElWid):
  15     F64 = 0
  16     F32 = 1
  17     F16 = 2
  18     BF16 = 3
  19
  20
  21 class IntElWid(ElWid):
  22     I64 = 0
  23     I32 = 1
  24     I16 = 2
  25     I8 = 3
  26
  27
  28 _T = TypeVar('_T')
  29 _T1 = TypeVar('_T1')
  30 _T2 = TypeVar('_T2')
  31
  32 _ElWid = Union[FpElWid, IntElWid]
  33
  34
  35 class SimdMap(Generic[_T]):
  36     ALL_ELWIDTHS: ClassVar[Tuple[_ElWid, ...]]
  37
  38     __map: Mapping[_ElWid, _T]
  39
  40     @overload
  41     @staticmethod
  42     def extract_value_algo(values: None,
  43                            default: _T2 = None, *,
  44                            simd_map_get: Callable[["SimdMap[_T]"], _T],
  45                            mapping_get: Callable[[Mapping[_ElWid, _T]], _T],
  46                            ) -> _T2: ...
  47
  48     @overload
  49     @staticmethod
  50     def extract_value_algo(values: SimdMap[_T],
  51                            default: _T2 = None, *,
  52                            simd_map_get: Callable[["SimdMap[_T]"], _T],
  53                            mapping_get: Callable[[Mapping[_ElWid, _T]], _T],
  54                            ) -> Union[_T, _T2]: ...
  55
  56     @overload
  57     @staticmethod
  58     def extract_value_algo(values: Mapping[_ElWid, _T],
  59                            default: _T2 = None, *,
  60                            simd_map_get: Callable[["SimdMap[_T]"], _T],
  61                            mapping_get: Callable[[Mapping[_ElWid, _T]], _T],
  62                            ) -> Union[_T, _T2]: ...
  63
  64     @overload
  65     @staticmethod
  66     def extract_value_algo(values: _T,
  67                            default: _T2 = None, *,
  68                            simd_map_get: Callable[["SimdMap[_T]"], _T],
  69                            mapping_get: Callable[[Mapping[_ElWid, _T]], _T],
  70                            ) -> Union[_T, _T2]: ...
  71
  72     @overload
  73     @classmethod
  74     def extract_value(cls,
  75                       elwid: _ElWid,
  76                       values: None,
  77                       default: _T2 = None) -> _T2: ...
  78
  79     @overload
  80     @classmethod
  81     def extract_value(cls,
  82                       elwid: _ElWid,
  83                       values: SimdMap[_T],
  84                       default: _T2 = None) -> Union[_T, _T2]: ...
  85
  86     @overload
  87     @classmethod
  88     def extract_value(cls,
  89                       elwid: _ElWid,
  90                       values: Mapping[_ElWid, _T],
  91                       default: _T2 = None) -> Union[_T, _T2]: ...
  92
  93     @overload
  94     @classmethod
  95     def extract_value(cls,
  96                       elwid: _ElWid,
  97                       values: _T,
  98                       default: _T2 = None) -> Union[_T, _T2]: ...
  99
 100     @overload
 101     def __init__(self, values: Optional[SimdMap[_T]] = None): ...
 102     @overload
 103     def __init__(self, values: Optional[Mapping[_ElWid, _T]] = None): ...
 104     @overload
 105     def __init__(self, values: Optional[_T] = None): ...
 106
 107     @property
 108     def mapping(self) -> Mapping[_ElWid, _T]: ...
 109
 110     def values(self) -> ValuesView[_T]: ...
 111
 112     def keys(self) -> KeysView[_ElWid]: ...
 113
 114     def items(self) -> ItemsView[_ElWid, _T]: ...
 115
 116     @overload
 117     @classmethod
 118     def map_with_elwid(cls,
 119                        f: Callable[[_ElWid],
 120                                    SimdMap[_T]],
 121                        ) -> SimdMap[_T]: ...
 122
 123     @overload
 124     @classmethod
 125     def map_with_elwid(cls,
 126                        f: Callable[[_ElWid],
 127                                    Mapping[_ElWid, Optional[_T]]],
 128                        ) -> SimdMap[_T]: ...
 129
 130     @overload
 131     @classmethod
 132     def map_with_elwid(cls,
 133                        f: Callable[[_ElWid],
 134                                    Optional[_T]],
 135                        ) -> SimdMap[_T]: ...
 136
 137     @overload
 138     @classmethod
 139     def map_with_elwid(cls,
 140                        f: Callable[[_ElWid, _T1],
 141                                    SimdMap[_T]],
 142                        __arg1: SimdMap[_T1],
 143                        ) -> SimdMap[_T]: ...
 144
 145     @overload
 146     @classmethod
 147     def map_with_elwid(cls,
 148                        f: Callable[[_ElWid, _T1],
 149                                    Mapping[_ElWid, Optional[_T]]],
 150                        __arg1: SimdMap[_T1],
 151                        ) -> SimdMap[_T]: ...
 152
 153     @overload
 154     @classmethod
 155     def map_with_elwid(cls,
 156                        f: Callable[[_ElWid, _T1],
 157                                    Optional[_T]],
 158                        __arg1: SimdMap[_T1],
 159                        ) -> SimdMap[_T]: ...
 160
 161     @overload
 162     @classmethod
 163     def map_with_elwid(cls,
 164                        f: Callable[[_ElWid, _T1],
 165                                    SimdMap[_T]],
 166                        __arg1: Mapping[_ElWid, Optional[_T1]],
 167                        ) -> SimdMap[_T]: ...
 168
 169     @overload
 170     @classmethod
 171     def map_with_elwid(cls,
 172                        f: Callable[[_ElWid, _T1],
 173                                    Mapping[_ElWid, Optional[_T]]],
 174                        __arg1: Mapping[_ElWid, Optional[_T1]],
 175                        ) -> SimdMap[_T]: ...
 176
 177     @overload
 178     @classmethod
 179     def map_with_elwid(cls,
 180                        f: Callable[[_ElWid, _T1],
 181                                    Optional[_T]],
 182                        __arg1: Mapping[_ElWid, Optional[_T1]],
 183                        ) -> SimdMap[_T]: ...
 184
 185     @overload
 186     @classmethod
 187     def map_with_elwid(cls,
 188                        f: Callable[[_ElWid, _T1],
 189                                    SimdMap[_T]],
 190                        __arg1: Optional[_T1],
 191                        ) -> SimdMap[_T]: ...
 192
 193     @overload
 194     @classmethod
 195     def map_with_elwid(cls,
 196                        f: Callable[[_ElWid, _T1],
 197                                    Mapping[_ElWid, Optional[_T]]],
 198                        __arg1: Optional[_T1],
 199                        ) -> SimdMap[_T]: ...
 200
 201     @overload
 202     @classmethod
 203     def map_with_elwid(cls,
 204                        f: Callable[[_ElWid, _T1],
 205                                    Optional[_T]],
 206                        __arg1: Optional[_T1],
 207                        ) -> SimdMap[_T]: ...
 208
 209     @overload
 210     @classmethod
 211     def map_with_elwid(cls,
 212                        f: Callable[[_ElWid, _T1, _T2],
 213                                    SimdMap[_T]],
 214                        __arg1: SimdMap[_T1],
 215                        __arg2: SimdMap[_T2],
 216                        ) -> SimdMap[_T]: ...
 217
 218     @overload
 219     @classmethod
 220     def map_with_elwid(cls,
 221                        f: Callable[[_ElWid, _T1, _T2],
 222                                    Mapping[_ElWid, Optional[_T]]],
 223                        __arg1: SimdMap[_T1],
 224                        __arg2: SimdMap[_T2],
 225                        ) -> SimdMap[_T]: ...
 226
 227     @overload
 228     @classmethod
 229     def map_with_elwid(cls,
 230                        f: Callable[[_ElWid, _T1, _T2],
 231                                    Optional[_T]],
 232                        __arg1: SimdMap[_T1],
 233                        __arg2: SimdMap[_T2],
 234                        ) -> SimdMap[_T]: ...
 235
 236     @overload
 237     @classmethod
 238     def map_with_elwid(cls,
 239                        f: Callable[[_ElWid, _T1, _T2],
 240                                    SimdMap[_T]],
 241                        __arg1: Mapping[_ElWid, Optional[_T1]],
 242                        __arg2: SimdMap[_T2],
 243                        ) -> SimdMap[_T]: ...
 244
 245     @overload
 246     @classmethod
 247     def map_with_elwid(cls,
 248                        f: Callable[[_ElWid, _T1, _T2],
 249                                    Mapping[_ElWid, Optional[_T]]],
 250                        __arg1: Mapping[_ElWid, Optional[_T1]],
 251                        __arg2: SimdMap[_T2],
 252                        ) -> SimdMap[_T]: ...
 253
 254     @overload
 255     @classmethod
 256     def map_with_elwid(cls,
 257                        f: Callable[[_ElWid, _T1, _T2],
 258                                    Optional[_T]],
 259                        __arg1: Mapping[_ElWid, Optional[_T1]],
 260                        __arg2: SimdMap[_T2],
 261                        ) -> SimdMap[_T]: ...
 262
 263     @overload
 264     @classmethod
 265     def map_with_elwid(cls,
 266                        f: Callable[[_ElWid, _T1, _T2],
 267                                    SimdMap[_T]],
 268                        __arg1: Optional[_T1],
 269                        __arg2: SimdMap[_T2],
 270                        ) -> SimdMap[_T]: ...
 271
 272     @overload
 273     @classmethod
 274     def map_with_elwid(cls,
 275                        f: Callable[[_ElWid, _T1, _T2],
 276                                    Mapping[_ElWid, Optional[_T]]],
 277                        __arg1: Optional[_T1],
 278                        __arg2: SimdMap[_T2],
 279                        ) -> SimdMap[_T]: ...
 280
 281     @overload
 282     @classmethod
 283     def map_with_elwid(cls,
 284                        f: Callable[[_ElWid, _T1, _T2],
 285                                    Optional[_T]],
 286                        __arg1: Optional[_T1],
 287                        __arg2: SimdMap[_T2],
 288                        ) -> SimdMap[_T]: ...
 289
 290     @overload
 291     @classmethod
 292     def map_with_elwid(cls,
 293                        f: Callable[[_ElWid, _T1, _T2],
 294                                    SimdMap[_T]],
 295                        __arg1: SimdMap[_T1],
 296                        __arg2: Mapping[_ElWid, Optional[_T2]],
 297                        ) -> SimdMap[_T]: ...
 298
 299     @overload
 300     @classmethod
 301     def map_with_elwid(cls,
 302                        f: Callable[[_ElWid, _T1, _T2],
 303                                    Mapping[_ElWid, Optional[_T]]],
 304                        __arg1: SimdMap[_T1],
 305                        __arg2: Mapping[_ElWid, Optional[_T2]],
 306                        ) -> SimdMap[_T]: ...
 307
 308     @overload
 309     @classmethod
 310     def map_with_elwid(cls,
 311                        f: Callable[[_ElWid, _T1, _T2],
 312                                    Optional[_T]],
 313                        __arg1: SimdMap[_T1],
 314                        __arg2: Mapping[_ElWid, Optional[_T2]],
 315                        ) -> SimdMap[_T]: ...
 316
 317     @overload
 318     @classmethod
 319     def map_with_elwid(cls,
 320                        f: Callable[[_ElWid, _T1, _T2],
 321                                    SimdMap[_T]],
 322                        __arg1: Mapping[_ElWid, Optional[_T1]],
 323                        __arg2: Mapping[_ElWid, Optional[_T2]],
 324                        ) -> SimdMap[_T]: ...
 325
 326     @overload
 327     @classmethod
 328     def map_with_elwid(cls,
 329                        f: Callable[[_ElWid, _T1, _T2],
 330                                    Mapping[_ElWid, Optional[_T]]],
 331                        __arg1: Mapping[_ElWid, Optional[_T1]],
 332                        __arg2: Mapping[_ElWid, Optional[_T2]],
 333                        ) -> SimdMap[_T]: ...
 334
 335     @overload
 336     @classmethod
 337     def map_with_elwid(cls,
 338                        f: Callable[[_ElWid, _T1, _T2],
 339                                    Optional[_T]],
 340                        __arg1: Mapping[_ElWid, Optional[_T1]],
 341                        __arg2: Mapping[_ElWid, Optional[_T2]],
 342                        ) -> SimdMap[_T]: ...
 343
 344     @overload
 345     @classmethod
 346     def map_with_elwid(cls,
 347                        f: Callable[[_ElWid, _T1, _T2],
 348                                    SimdMap[_T]],
 349                        __arg1: Optional[_T1],
 350                        __arg2: Mapping[_ElWid, Optional[_T2]],
 351                        ) -> SimdMap[_T]: ...
 352
 353     @overload
 354     @classmethod
 355     def map_with_elwid(cls,
 356                        f: Callable[[_ElWid, _T1, _T2],
 357                                    Mapping[_ElWid, Optional[_T]]],
 358                        __arg1: Optional[_T1],
 359                        __arg2: Mapping[_ElWid, Optional[_T2]],
 360                        ) -> SimdMap[_T]: ...
 361
 362     @overload
 363     @classmethod
 364     def map_with_elwid(cls,
 365                        f: Callable[[_ElWid, _T1, _T2],
 366                                    Optional[_T]],
 367                        __arg1: Optional[_T1],
 368                        __arg2: Mapping[_ElWid, Optional[_T2]],
 369                        ) -> SimdMap[_T]: ...
 370
 371     @overload
 372     @classmethod
 373     def map_with_elwid(cls,
 374                        f: Callable[[_ElWid, _T1, _T2],
 375                                    SimdMap[_T]],
 376                        __arg1: SimdMap[_T1],
 377                        __arg2: Optional[_T2],
 378                        ) -> SimdMap[_T]: ...
 379
 380     @overload
 381     @classmethod
 382     def map_with_elwid(cls,
 383                        f: Callable[[_ElWid, _T1, _T2],
 384                                    Mapping[_ElWid, Optional[_T]]],
 385                        __arg1: SimdMap[_T1],
 386                        __arg2: Optional[_T2],
 387                        ) -> SimdMap[_T]: ...
 388
 389     @overload
 390     @classmethod
 391     def map_with_elwid(cls,
 392                        f: Callable[[_ElWid, _T1, _T2],
 393                                    Optional[_T]],
 394                        __arg1: SimdMap[_T1],
 395                        __arg2: Optional[_T2],
 396                        ) -> SimdMap[_T]: ...
 397
 398     @overload
 399     @classmethod
 400     def map_with_elwid(cls,
 401                        f: Callable[[_ElWid, _T1, _T2],
 402                                    SimdMap[_T]],
 403                        __arg1: Mapping[_ElWid, Optional[_T1]],
 404                        __arg2: Optional[_T2],
 405                        ) -> SimdMap[_T]: ...
 406
 407     @overload
 408     @classmethod
 409     def map_with_elwid(cls,
 410                        f: Callable[[_ElWid, _T1, _T2],
 411                                    Mapping[_ElWid, Optional[_T]]],
 412                        __arg1: Mapping[_ElWid, Optional[_T1]],
 413                        __arg2: Optional[_T2],
 414                        ) -> SimdMap[_T]: ...
 415
 416     @overload
 417     @classmethod
 418     def map_with_elwid(cls,
 419                        f: Callable[[_ElWid, _T1, _T2],
 420                                    Optional[_T]],
 421                        __arg1: Mapping[_ElWid, Optional[_T1]],
 422                        __arg2: Optional[_T2],
 423                        ) -> SimdMap[_T]: ...
 424
 425     @overload
 426     @classmethod
 427     def map_with_elwid(cls,
 428                        f: Callable[[_ElWid, _T1, _T2],
 429                                    SimdMap[_T]],
 430                        __arg1: Optional[_T1],
 431                        __arg2: Optional[_T2],
 432                        ) -> SimdMap[_T]: ...
 433
 434     @overload
 435     @classmethod
 436     def map_with_elwid(cls,
 437                        f: Callable[[_ElWid, _T1, _T2],
 438                                    Mapping[_ElWid, Optional[_T]]],
 439                        __arg1: Optional[_T1],
 440                        __arg2: Optional[_T2],
 441                        ) -> SimdMap[_T]: ...
 442
 443     @overload
 444     @classmethod
 445     def map_with_elwid(cls,
 446                        f: Callable[[_ElWid, _T1, _T2],
 447                                    Optional[_T]],
 448                        __arg1: Optional[_T1],
 449                        __arg2: Optional[_T2],
 450                        ) -> SimdMap[_T]: ...
 451
 452     @overload
 453     @classmethod
 454     def map_with_elwid(cls,
 455                        f: Callable[..., SimdMap[_T]],
 456                        *args: Any) -> SimdMap[_T]:
 457         ...
 458
 459     @overload
 460     @classmethod
 461     def map_with_elwid(cls,
 462                        f: Callable[..., Mapping[_ElWid, Optional[_T]]],
 463                        *args: Any) -> SimdMap[_T]:
 464         ...
 465
 466     @overload
 467     @classmethod
 468     def map_with_elwid(cls,
 469                        f: Callable[..., Optional[_T]],
 470                        *args: Any) -> SimdMap[_T]:
 471         ...
 472
 473     @overload
 474     @classmethod
 475     def map(cls,
 476             f: Callable[[],
 477                         SimdMap[_T]],
 478             ) -> SimdMap[_T]: ...
 479
 480     @overload
 481     @classmethod
 482     def map(cls,
 483             f: Callable[[],
 484                         Mapping[_ElWid, Optional[_T]]],
 485             ) -> SimdMap[_T]: ...
 486
 487     @overload
 488     @classmethod
 489     def map(cls,
 490             f: Callable[[],
 491                         Optional[_T]],
 492             ) -> SimdMap[_T]: ...
 493
 494     @overload
 495     @classmethod
 496     def map(cls,
 497             f: Callable[[_T1],
 498                         SimdMap[_T]],
 499             __arg1: SimdMap[_T1],
 500             ) -> SimdMap[_T]: ...
 501
 502     @overload
 503     @classmethod
 504     def map(cls,
 505             f: Callable[[_T1],
 506                         Mapping[_ElWid, Optional[_T]]],
 507             __arg1: SimdMap[_T1],
 508             ) -> SimdMap[_T]: ...
 509
 510     @overload
 511     @classmethod
 512     def map(cls,
 513             f: Callable[[_T1],
 514                         Optional[_T]],
 515             __arg1: SimdMap[_T1],
 516             ) -> SimdMap[_T]: ...
 517
 518     @overload
 519     @classmethod
 520     def map(cls,
 521             f: Callable[[_T1],
 522                         SimdMap[_T]],
 523             __arg1: Mapping[_ElWid, Optional[_T1]],
 524             ) -> SimdMap[_T]: ...
 525
 526     @overload
 527     @classmethod
 528     def map(cls,
 529             f: Callable[[_T1],
 530                         Mapping[_ElWid, Optional[_T]]],
 531             __arg1: Mapping[_ElWid, Optional[_T1]],
 532             ) -> SimdMap[_T]: ...
 533
 534     @overload
 535     @classmethod
 536     def map(cls,
 537             f: Callable[[_T1],
 538                         Optional[_T]],
 539             __arg1: Mapping[_ElWid, Optional[_T1]],
 540             ) -> SimdMap[_T]: ...
 541
 542     @overload
 543     @classmethod
 544     def map(cls,
 545             f: Callable[[_T1],
 546                         SimdMap[_T]],
 547             __arg1: Optional[_T1],
 548             ) -> SimdMap[_T]: ...
 549
 550     @overload
 551     @classmethod
 552     def map(cls,
 553             f: Callable[[_T1],
 554                         Mapping[_ElWid, Optional[_T]]],
 555             __arg1: Optional[_T1],
 556             ) -> SimdMap[_T]: ...
 557
 558     @overload
 559     @classmethod
 560     def map(cls,
 561             f: Callable[[_T1],
 562                         Optional[_T]],
 563             __arg1: Optional[_T1],
 564             ) -> SimdMap[_T]: ...
 565
 566     @overload
 567     @classmethod
 568     def map(cls,
 569             f: Callable[[_T1, _T2],
 570                         SimdMap[_T]],
 571             __arg1: SimdMap[_T1],
 572             __arg2: SimdMap[_T2],
 573             ) -> SimdMap[_T]: ...
 574
 575     @overload
 576     @classmethod
 577     def map(cls,
 578             f: Callable[[_T1, _T2],
 579                         Mapping[_ElWid, Optional[_T]]],
 580             __arg1: SimdMap[_T1],
 581             __arg2: SimdMap[_T2],
 582             ) -> SimdMap[_T]: ...
 583
 584     @overload
 585     @classmethod
 586     def map(cls,
 587             f: Callable[[_T1, _T2],
 588                         Optional[_T]],
 589             __arg1: SimdMap[_T1],
 590             __arg2: SimdMap[_T2],
 591             ) -> SimdMap[_T]: ...
 592
 593     @overload
 594     @classmethod
 595     def map(cls,
 596             f: Callable[[_T1, _T2],
 597                         SimdMap[_T]],
 598             __arg1: Mapping[_ElWid, Optional[_T1]],
 599             __arg2: SimdMap[_T2],
 600             ) -> SimdMap[_T]: ...
 601
 602     @overload
 603     @classmethod
 604     def map(cls,
 605             f: Callable[[_T1, _T2],
 606                         Mapping[_ElWid, Optional[_T]]],
 607             __arg1: Mapping[_ElWid, Optional[_T1]],
 608             __arg2: SimdMap[_T2],
 609             ) -> SimdMap[_T]: ...
 610
 611     @overload
 612     @classmethod
 613     def map(cls,
 614             f: Callable[[_T1, _T2],
 615                         Optional[_T]],
 616             __arg1: Mapping[_ElWid, Optional[_T1]],
 617             __arg2: SimdMap[_T2],
 618             ) -> SimdMap[_T]: ...
 619
 620     @overload
 621     @classmethod
 622     def map(cls,
 623             f: Callable[[_T1, _T2],
 624                         SimdMap[_T]],
 625             __arg1: Optional[_T1],
 626             __arg2: SimdMap[_T2],
 627             ) -> SimdMap[_T]: ...
 628
 629     @overload
 630     @classmethod
 631     def map(cls,
 632             f: Callable[[_T1, _T2],
 633                         Mapping[_ElWid, Optional[_T]]],
 634             __arg1: Optional[_T1],
 635             __arg2: SimdMap[_T2],
 636             ) -> SimdMap[_T]: ...
 637
 638     @overload
 639     @classmethod
 640     def map(cls,
 641             f: Callable[[_T1, _T2],
 642                         Optional[_T]],
 643             __arg1: Optional[_T1],
 644             __arg2: SimdMap[_T2],
 645             ) -> SimdMap[_T]: ...
 646
 647     @overload
 648     @classmethod
 649     def map(cls,
 650             f: Callable[[_T1, _T2],
 651                         SimdMap[_T]],
 652             __arg1: SimdMap[_T1],
 653             __arg2: Mapping[_ElWid, Optional[_T2]],
 654             ) -> SimdMap[_T]: ...
 655
 656     @overload
 657     @classmethod
 658     def map(cls,
 659             f: Callable[[_T1, _T2],
 660                         Mapping[_ElWid, Optional[_T]]],
 661             __arg1: SimdMap[_T1],
 662             __arg2: Mapping[_ElWid, Optional[_T2]],
 663             ) -> SimdMap[_T]: ...
 664
 665     @overload
 666     @classmethod
 667     def map(cls,
 668             f: Callable[[_T1, _T2],
 669                         Optional[_T]],
 670             __arg1: SimdMap[_T1],
 671             __arg2: Mapping[_ElWid, Optional[_T2]],
 672             ) -> SimdMap[_T]: ...
 673
 674     @overload
 675     @classmethod
 676     def map(cls,
 677             f: Callable[[_T1, _T2],
 678                         SimdMap[_T]],
 679             __arg1: Mapping[_ElWid, Optional[_T1]],
 680             __arg2: Mapping[_ElWid, Optional[_T2]],
 681             ) -> SimdMap[_T]: ...
 682
 683     @overload
 684     @classmethod
 685     def map(cls,
 686             f: Callable[[_T1, _T2],
 687                         Mapping[_ElWid, Optional[_T]]],
 688             __arg1: Mapping[_ElWid, Optional[_T1]],
 689             __arg2: Mapping[_ElWid, Optional[_T2]],
 690             ) -> SimdMap[_T]: ...
 691
 692     @overload
 693     @classmethod
 694     def map(cls,
 695             f: Callable[[_T1, _T2],
 696                         Optional[_T]],
 697             __arg1: Mapping[_ElWid, Optional[_T1]],
 698             __arg2: Mapping[_ElWid, Optional[_T2]],
 699             ) -> SimdMap[_T]: ...
 700
 701     @overload
 702     @classmethod
 703     def map(cls,
 704             f: Callable[[_T1, _T2],
 705                         SimdMap[_T]],
 706             __arg1: Optional[_T1],
 707             __arg2: Mapping[_ElWid, Optional[_T2]],
 708             ) -> SimdMap[_T]: ...
 709
 710     @overload
 711     @classmethod
 712     def map(cls,
 713             f: Callable[[_T1, _T2],
 714                         Mapping[_ElWid, Optional[_T]]],
 715             __arg1: Optional[_T1],
 716             __arg2: Mapping[_ElWid, Optional[_T2]],
 717             ) -> SimdMap[_T]: ...
 718
 719     @overload
 720     @classmethod
 721     def map(cls,
 722             f: Callable[[_T1, _T2],
 723                         Optional[_T]],
 724             __arg1: Optional[_T1],
 725             __arg2: Mapping[_ElWid, Optional[_T2]],
 726             ) -> SimdMap[_T]: ...
 727
 728     @overload
 729     @classmethod
 730     def map(cls,
 731             f: Callable[[_T1, _T2],
 732                         SimdMap[_T]],
 733             __arg1: SimdMap[_T1],
 734             __arg2: Optional[_T2],
 735             ) -> SimdMap[_T]: ...
 736
 737     @overload
 738     @classmethod
 739     def map(cls,
 740             f: Callable[[_T1, _T2],
 741                         Mapping[_ElWid, Optional[_T]]],
 742             __arg1: SimdMap[_T1],
 743             __arg2: Optional[_T2],
 744             ) -> SimdMap[_T]: ...
 745
 746     @overload
 747     @classmethod
 748     def map(cls,
 749             f: Callable[[_T1, _T2],
 750                         Optional[_T]],
 751             __arg1: SimdMap[_T1],
 752             __arg2: Optional[_T2],
 753             ) -> SimdMap[_T]: ...
 754
 755     @overload
 756     @classmethod
 757     def map(cls,
 758             f: Callable[[_T1, _T2],
 759                         SimdMap[_T]],
 760             __arg1: Mapping[_ElWid, Optional[_T1]],
 761             __arg2: Optional[_T2],
 762             ) -> SimdMap[_T]: ...
 763
 764     @overload
 765     @classmethod
 766     def map(cls,
 767             f: Callable[[_T1, _T2],
 768                         Mapping[_ElWid, Optional[_T]]],
 769             __arg1: Mapping[_ElWid, Optional[_T1]],
 770             __arg2: Optional[_T2],
 771             ) -> SimdMap[_T]: ...
 772
 773     @overload
 774     @classmethod
 775     def map(cls,
 776             f: Callable[[_T1, _T2],
 777                         Optional[_T]],
 778             __arg1: Mapping[_ElWid, Optional[_T1]],
 779             __arg2: Optional[_T2],
 780             ) -> SimdMap[_T]: ...
 781
 782     @overload
 783     @classmethod
 784     def map(cls,
 785             f: Callable[[_T1, _T2],
 786                         SimdMap[_T]],
 787             __arg1: Optional[_T1],
 788             __arg2: Optional[_T2],
 789             ) -> SimdMap[_T]: ...
 790
 791     @overload
 792     @classmethod
 793     def map(cls,
 794             f: Callable[[_T1, _T2],
 795                         Mapping[_ElWid, Optional[_T]]],
 796             __arg1: Optional[_T1],
 797             __arg2: Optional[_T2],
 798             ) -> SimdMap[_T]: ...
 799
 800     @overload
 801     @classmethod
 802     def map(cls,
 803             f: Callable[[_T1, _T2],
 804                         Optional[_T]],
 805             __arg1: Optional[_T1],
 806             __arg2: Optional[_T2],
 807             ) -> SimdMap[_T]: ...
 808
 809     @overload
 810     @classmethod
 811     def map(cls,
 812             f: Callable[..., SimdMap[_T]],
 813             *args: Any) -> SimdMap[_T]:
 814         ...
 815
 816     @overload
 817     @classmethod
 818     def map(cls,
 819             f: Callable[..., Mapping[_ElWid, Optional[_T]]],
 820             *args: Any) -> SimdMap[_T]:
 821         ...
 822
 823     @overload
 824     @classmethod
 825     def map(cls,
 826             f: Callable[..., Optional[_T]],
 827             *args: Any) -> SimdMap[_T]:
 828         ...
 829
 830     @overload
 831     def get(self, elwid: _ElWid, default: Any = None, *,
 832             raise_key_error: Literal[True]) -> _T: ...
 833
 834     @overload
 835     def get(self, elwid: _ElWid, default: _T2 = None, *,
 836             raise_key_error: bool = False) -> Union[_T, _T2]: ...
 837
 838     def __iter__(self) -> Iterator[Tuple[_ElWid, _T]]: ...
 839
 840     @overload
 841     def __add__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 842     @overload
 843     def __add__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 844     @overload
 845     def __add__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 846     @overload
 847     def __add__(self, other: Any) -> SimdMap[Any]: ...
 848
 849     @overload
 850     def __radd__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 851
 852     @overload
 853     def __radd__(self, other: Mapping[_ElWid,
 854                                       Optional[_T]]) -> SimdMap[_T]: ...
 855
 856     @overload
 857     def __radd__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 858     @overload
 859     def __radd__(self, other: Any) -> SimdMap[Any]: ...
 860
 861     @overload
 862     def __sub__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 863     @overload
 864     def __sub__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 865     @overload
 866     def __sub__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 867     @overload
 868     def __sub__(self, other: Any) -> SimdMap[Any]: ...
 869
 870     @overload
 871     def __rsub__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 872
 873     @overload
 874     def __rsub__(self, other: Mapping[_ElWid,
 875                                       Optional[_T]]) -> SimdMap[_T]: ...
 876
 877     @overload
 878     def __rsub__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 879     @overload
 880     def __rsub__(self, other: Any) -> SimdMap[Any]: ...
 881
 882     @overload
 883     def __mul__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 884     @overload
 885     def __mul__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 886     @overload
 887     def __mul__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 888     @overload
 889     def __mul__(self, other: Any) -> SimdMap[Any]: ...
 890
 891     @overload
 892     def __rmul__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 893
 894     @overload
 895     def __rmul__(self, other: Mapping[_ElWid,
 896                                       Optional[_T]]) -> SimdMap[_T]: ...
 897
 898     @overload
 899     def __rmul__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 900     @overload
 901     def __rmul__(self, other: Any) -> SimdMap[Any]: ...
 902
 903     @overload
 904     def __floordiv__(
 905         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 906
 907     @overload
 908     def __floordiv__(
 909         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 910
 911     @overload
 912     def __floordiv__(
 913         self, other: Optional[_T]) -> SimdMap[_T]: ...
 914
 915     @overload
 916     def __floordiv__(self, other: Any) -> SimdMap[Any]: ...
 917
 918     @overload
 919     def __rfloordiv__(
 920         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 921
 922     @overload
 923     def __rfloordiv__(
 924         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 925
 926     @overload
 927     def __rfloordiv__(
 928         self, other: Optional[_T]) -> SimdMap[_T]: ...
 929
 930     @overload
 931     def __rfloordiv__(self, other: Any) -> SimdMap[Any]: ...
 932
 933     @overload
 934     def __truediv__(
 935         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 936
 937     @overload
 938     def __truediv__(
 939         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 940
 941     @overload
 942     def __truediv__(
 943         self, other: Optional[_T]) -> SimdMap[_T]: ...
 944
 945     @overload
 946     def __truediv__(self, other: Any) -> SimdMap[Any]: ...
 947
 948     @overload
 949     def __rtruediv__(
 950         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 951
 952     @overload
 953     def __rtruediv__(
 954         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 955
 956     @overload
 957     def __rtruediv__(
 958         self, other: Optional[_T]) -> SimdMap[_T]: ...
 959
 960     @overload
 961     def __rtruediv__(self, other: Any) -> SimdMap[Any]: ...
 962
 963     @overload
 964     def __mod__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 965     @overload
 966     def __mod__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 967     @overload
 968     def __mod__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 969     @overload
 970     def __mod__(self, other: Any) -> SimdMap[Any]: ...
 971
 972     @overload
 973     def __rmod__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 974
 975     @overload
 976     def __rmod__(self, other: Mapping[_ElWid,
 977                                       Optional[_T]]) -> SimdMap[_T]: ...
 978
 979     @overload
 980     def __rmod__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 981     @overload
 982     def __rmod__(self, other: Any) -> SimdMap[Any]: ...
 983
 984     def __abs__(self) -> SimdMap[_T]: ...
 985
 986     @overload
 987     def __and__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 988     @overload
 989     def __and__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
 990     @overload
 991     def __and__(self, other: Optional[_T]) -> SimdMap[_T]: ...
 992     @overload
 993     def __and__(self, other: Any) -> SimdMap[Any]: ...
 994
 995     @overload
 996     def __rand__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
 997
 998     @overload
 999     def __rand__(self, other: Mapping[_ElWid,
1000                                       Optional[_T]]) -> SimdMap[_T]: ...
1001
1002     @overload
1003     def __rand__(self, other: Optional[_T]) -> SimdMap[_T]: ...
1004     @overload
1005     def __rand__(self, other: Any) -> SimdMap[Any]: ...
1006
1007     @overload
1008     def __divmod__(
1009         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1010
1011     @overload
1012     def __divmod__(
1013         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1014
1015     @overload
1016     def __divmod__(
1017         self, other: Optional[_T]) -> SimdMap[_T]: ...
1018
1019     @overload
1020     def __divmod__(self, other: Any) -> SimdMap[Any]: ...
1021
1022     def __ceil__(self) -> SimdMap[int]: ...
1023
1024     def __float__(self) -> SimdMap[float]: ...
1025
1026     def __floor__(self) -> SimdMap[int]: ...
1027
1028     def __eq__(self, other: Any) -> bool: ...
1029
1030     def __hash__(self) -> int: ...
1031
1032     def __repr__(self) -> str: ...
1033
1034     def __invert__(self) -> SimdMap[_T]: ...
1035
1036     @overload
1037     def __lshift__(
1038         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1039
1040     @overload
1041     def __lshift__(
1042         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1043
1044     @overload
1045     def __lshift__(
1046         self, other: Optional[_T]) -> SimdMap[_T]: ...
1047
1048     @overload
1049     def __lshift__(self, other: Any) -> SimdMap[Any]: ...
1050
1051     @overload
1052     def __rlshift__(
1053         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1054
1055     @overload
1056     def __rlshift__(
1057         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1058
1059     @overload
1060     def __rlshift__(
1061         self, other: Optional[_T]) -> SimdMap[_T]: ...
1062
1063     @overload
1064     def __rlshift__(self, other: Any) -> SimdMap[Any]: ...
1065
1066     @overload
1067     def __rshift__(
1068         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1069
1070     @overload
1071     def __rshift__(
1072         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1073
1074     @overload
1075     def __rshift__(
1076         self, other: Optional[_T]) -> SimdMap[_T]: ...
1077
1078     @overload
1079     def __rshift__(self, other: Any) -> SimdMap[Any]: ...
1080
1081     @overload
1082     def __rrshift__(
1083         self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1084
1085     @overload
1086     def __rrshift__(
1087         self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1088
1089     @overload
1090     def __rrshift__(
1091         self, other: Optional[_T]) -> SimdMap[_T]: ...
1092
1093     @overload
1094     def __rrshift__(self, other: Any) -> SimdMap[Any]: ...
1095
1096     def __neg__(self) -> SimdMap[_T]: ...
1097
1098     def __pos__(self) -> SimdMap[_T]: ...
1099
1100     @overload
1101     def __or__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1102     @overload
1103     def __or__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1104     @overload
1105     def __or__(self, other: Optional[_T]) -> SimdMap[_T]: ...
1106     @overload
1107     def __or__(self, other: Any) -> SimdMap[Any]: ...
1108
1109     @overload
1110     def __ror__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1111     @overload
1112     def __ror__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1113     @overload
1114     def __ror__(self, other: Optional[_T]) -> SimdMap[_T]: ...
1115     @overload
1116     def __ror__(self, other: Any) -> SimdMap[Any]: ...
1117
1118     @overload
1119     def __xor__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1120     @overload
1121     def __xor__(self, other: Mapping[_ElWid, Optional[_T]]) -> SimdMap[_T]: ...
1122     @overload
1123     def __xor__(self, other: Optional[_T]) -> SimdMap[_T]: ...
1124     @overload
1125     def __xor__(self, other: Any) -> SimdMap[Any]: ...
1126
1127     @overload
1128     def __rxor__(self, other: SimdMap[_T]) -> SimdMap[_T]: ...
1129
1130     @overload
1131     def __rxor__(self, other: Mapping[_ElWid,
1132                                       Optional[_T]]) -> SimdMap[_T]: ...
1133
1134     @overload
1135     def __rxor__(self, other: Optional[_T]) -> SimdMap[_T]: ...
1136     @overload
1137     def __rxor__(self, other: Any) -> SimdMap[Any]: ...
1138
1139     def missing_elwidths(self, *,
1140                          all_elwidths: Optional[Iterable[_ElWid]] = None,
1141                          ) -> Iterable[_ElWid]: ...
1142
1143
1144 class SimdWHintMap(SimdMap[_T]):
1145     @overload
1146     @classmethod
1147     def extract_width_hint(cls,
1148                            values: None,
1149                            default: _T2 = None) -> _T2: ...
1150
1151     @overload
1152     @classmethod
1153     def extract_width_hint(cls,
1154                            values: SimdMap[_T],
1155                            default: _T2 = None) -> Union[_T, _T2]: ...
1156
1157     @overload
1158     @classmethod
1159     def extract_width_hint(cls,
1160                            values: Mapping[_ElWid, _T],
1161                            default: _T2 = None) -> Union[_T, _T2]: ...
1162
1163     @overload
1164     @classmethod
1165     def extract_width_hint(cls,
1166                            values: _T,
1167                            default: _T2 = None) -> Union[_T, _T2]: ...
1168
1169     @overload
1170     def __init__(self, values: Optional[SimdMap[_T]] = None, *,
1171                  width_hint: Optional[SimdMap[_T]] = None): ...
1172
1173     @overload
1174     def __init__(self, values: Optional[Mapping[_ElWid, _T]] = None, *,
1175                  width_hint: Optional[SimdMap[_T]] = None): ...
1176
1177     @overload
1178     def __init__(self, values: Optional[_T] = None, *,
1179                  width_hint: Optional[SimdMap[_T]] = None): ...
1180
1181     @overload
1182     def __init__(self, values: Optional[SimdMap[_T]] = None, *,
1183                  width_hint: Optional[Mapping[_ElWid, _T]] = None): ...
1184
1185     @overload
1186     def __init__(self, values: Optional[Mapping[_ElWid, _T]] = None, *,
1187                  width_hint: Optional[Mapping[_ElWid, _T]] = None): ...
1188
1189     @overload
1190     def __init__(self, values: Optional[_T] = None, *,
1191                  width_hint: Optional[Mapping[_ElWid, _T]] = None): ...
1192
1193     @overload
1194     def __init__(self, values: Optional[SimdMap[_T]] = None, *,
1195                  width_hint: Optional[_T] = None): ...
1196
1197     @overload
1198     def __init__(self, values: Optional[Mapping[_ElWid, _T]] = None, *,
1199                  width_hint: Optional[_T] = None): ...
1200
1201     @overload
1202     def __init__(self, values: Optional[_T] = None, *,
1203                  width_hint: Optional[_T] = None): ...
1204
1205     @property
1206     def width_hint(self) -> _T: ...
1207
1208
1209 XLEN: SimdWHintMap[int] = ...
1210
1211 DEFAULT_FP_VEC_EL_COUNTS: SimdMap[int] = ...
1212
1213 DEFAULT_INT_VEC_EL_COUNTS: SimdMap[int] = ...