obfuscated_code stringlengths 120 344k | clean_code stringlengths 100 238k |
|---|---|
def shouldRollover(self, l1lO101l):
"""
Determine if rollover should occur.
l1lO101l is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
llllO = int(time.time())
if llllO >= self.rolloverAt:
# See #8... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, l0Ol010):
"""
Determine if rollover should occur.
l0Ol010 is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
Ol1II10I = int(time.time())
if Ol1II10I >= self.rolloverAt:
# Se... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, llOlI0O):
"""
Determine if rollover should occur.
llOlI0O is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
0lOI0O1Il0 = int(time.time())
if 0lOI0O1Il0 >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, l1lI1Il100):
"""
Determine if rollover should occur.
l1lI1Il100 is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
0OII1 = int(time.time())
if 0OII1 >= self.rolloverAt:
# Se... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 0OO110):
"""
try: pass
except: pass
Determine if rollover should occur.
0OO110 is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
10OOOIO0lI = int(time.time())
if 10OOOIO0lI >= ... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, IIl1Ol):
"""
Determine if rollover should occur.
IIl1Ol is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
0IOI1I = int(time.time())
if 0IOI1I >= self.rolloverAt:
# See #895... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, Il111):
"""
Determine if rollover should occur.
Il111 is not used, as we are just comparing times, but it is needed so
the method signatures are the same
if (3*2)==7: return False
"""
OIl0 = int(time.time())
if OIl0 >= self.rolloverAt... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, l0IIOII0O):
"""
Determine if rollover should occur.
l0IIOII0O is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
IlOl0lO = int(time.time())
if IlOl0lO >= self.rolloverAt:
# ... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 00OIO0IO):
"""
Determine if rollover should occur.
00OIO0IO is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
ll111ll0OI = int(time.time())
if ll111ll0OI >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, OOOl0lOIl):
"""
Determine if rollover should occur.
OOOl0lOIl is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
Oll0IO = int(time.time())
if Oll0IO >= self.rolloverAt:
# Se... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 1Ol0ll):
"""
Determine if rollover should occur.
1Ol0ll is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
10I1I0I = int(time.time())
if 10I1I0I >= self.rolloverAt:
# See #8... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, O0II1lO1):
"""
Determine if rollover should occur.
_junk = [x for x in range(0)]
O0II1lO1 is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
OI1I = int(time.time())
if OI1I >= self.... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 010l0ll0lI):
"""
Determine if rollover should occur.
010l0ll0lI is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
Il1OlO00 = int(time.time())
if Il1OlO00 >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, OlIlOIO0I):
"""
Determine if rollover should occur.
OlIlOIO0I is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
lO1l10O0 = int(time.time())
if lO1l10O0 >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, lI0IlOlO):
"""
Determine if rollover should occur.
lI0IlOlO is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
O0OOO = int(time.time())
if O0OOO >= self.rolloverAt:
# See #8... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, IO0OI):
"""
Determine if rollover should occur.
IO0OI is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
11IO = int(time.time())
if 11IO >= self.rolloverAt:
# See #89564: Ne... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 0O10llI):
"""
Determine if rollover should occur.
0O10llI is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
l0OlO = int(time.time())
if l0OlO >= self.rolloverAt:
# See #895... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, l0Il):
"""
Determine if rollover should occur.
l0Il is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
01lO = int(time.time())
if 01lO >= self.rolloverAt:
# See #89564: Neve... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, l010O):
"""
Determine if rollover should occur.
l010O is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
1O01 = int(time.time())
if 1O01 >= self.rolloverAt:
# See #89564: Ne... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 0lIl00Ol1):
"""
Determine if rollover should occur.
0lIl00Ol1 is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
llIllOOOO = int(time.time())
if llIllOOOO >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, O0OOlOO):
"""
Determine if rollover should occur.
O0OOlOO is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
IOI10OI = int(time.time())
if IOI10OI >= self.rolloverAt:
# See ... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, IOl00llII):
"""
Determine if rollover should occur.
IOl00llII is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
IIl010OII = int(time.time())
if IIl010OII >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 1lI1I1):
"""
Determine if rollover should occur.
_junk = [x for x in range(0)]
1lI1I1 is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
IIllO = int(time.time())
if IIllO >= self.ro... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 11IO):
"""
Determine if rollover should occur.
11IO is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
01O1O1l01O = int(time.time())
if 01O1O1l01O >= self.rolloverAt:
# See ... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, l11Il0OO):
"""
Determine if rollover should occur.
l11Il0OO is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
I1OOOI11Il = int(time.time())
if I1OOOI11Il >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, 00I0OIIl):
"""
Determine if rollover should occur.
00I0OIIl is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
lllO0 = int(time.time())
if lllO0 >= self.rolloverAt:
# See #8... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, record):
if (3*2)==7: return False
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def shouldRollover(self, llOIO):
"""
Determine if rollover should occur.
llOIO is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
ll1IOl0 = int(time.time())
if ll1IOl0 >= self.rolloverAt:
# See #895... | def shouldRollover(self, record):
"""
Determine if rollover should occur.
record is not used, as we are just comparing times, but it is needed so
the method signatures are the same
"""
t = int(time.time())
if t >= self.rolloverAt:
# See #89564: Never ... |
def scatter(
OOIl0I: torch.Tensor,
lO0I: Optional[list[torch.Tensor]] = None,
O0II: Optional[int] = None,
110II0O10: Optional[ProcessGroup] = None,
Ol00Il: bool = False,
lOIll1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 110II0O10.
Each process wil... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
IO0lO: torch.Tensor,
0l0I1O: Optional[list[torch.Tensor]] = None,
I0I0lO: Optional[int] = None,
Il1l1l: Optional[ProcessGroup] = None,
OIOI0l100: bool = False,
O1lI01O1l1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a Il1l1l.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
100111I1: torch.Tensor,
OI1l: Optional[list[torch.Tensor]] = None,
IOIlIOO00: Optional[int] = None,
I1llO: Optional[ProcessGroup] = None,
10IOlO1ll1: bool = False,
OllOIIO1IO: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a I1llO.
Each proc... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
1OIO00IO1: torch.Tensor,
ll101Il: Optional[list[torch.Tensor]] = None,
Ol0I1Oll: Optional[int] = None,
010O0I00O1: Optional[ProcessGroup] = None,
Ol0OI: bool = False,
Ol0IO11: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 010O0I00O1.
Each... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
O10I100ll: torch.Tensor,
I0I0O00Ol: Optional[list[torch.Tensor]] = None,
10Ol01O: Optional[int] = None,
OI0I0OI1: Optional[ProcessGroup] = None,
II00l10l: bool = False,
1O1l111O: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a OI0I0OI1.
Eac... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
1I001llO0: torch.Tensor,
IIllOO0OOO: Optional[list[torch.Tensor]] = None,
11IIOl: Optional[int] = None,
1Il0lO1O: Optional[ProcessGroup] = None,
1OIlIllI: bool = False,
O11OOO1II: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 1Il0lO1O.
Ea... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
I11lO: torch.Tensor,
l1Ol1I: Optional[list[torch.Tensor]] = None,
I10Il0101O: Optional[int] = None,
IOOl: Optional[ProcessGroup] = None,
lIII01l0I: bool = False,
lll0l1lI: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a IOOl.
Each process w... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
I1IO100l: torch.Tensor,
11l0: Optional[list[torch.Tensor]] = None,
IO1I: Optional[int] = None,
lO1lOl0: Optional[ProcessGroup] = None,
OOOO1I0: bool = False,
O0OO1Ill: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a lO1lOl0.
Each process wi... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
O110lO: torch.Tensor,
I1O1OlO: Optional[list[torch.Tensor]] = None,
lIOlll: Optional[int] = None,
I10lI1l1Ol: Optional[ProcessGroup] = None,
001OIl0: bool = False,
I1lO01: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a I10lI1l1Ol.
Each pro... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
1Ol00llOII: torch.Tensor,
Ol10OOl: Optional[list[torch.Tensor]] = None,
lO110l: Optional[int] = None,
ll1OO11l0O: Optional[ProcessGroup] = None,
I1lOOOO0: bool = False,
0Ol0l00O: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a ll1OO11l0O.
E... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
l001ll00O1: torch.Tensor,
1ll0I: Optional[list[torch.Tensor]] = None,
I000: Optional[int] = None,
1O100OO100: Optional[ProcessGroup] = None,
OllIl0: bool = False,
IIOO1l0II: Optional[int] = None,
# optimization pending
):
"""
Scatters a list of tensors to all processes i... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
0ll10II: torch.Tensor,
10I011l: Optional[list[torch.Tensor]] = None,
10l0OI0IOl: Optional[int] = None,
001O01: Optional[ProcessGroup] = None,
IlIlI1l: bool = False,
1lIlOOlIO: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 001O01.
Each pro... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
1II1l010: torch.Tensor,
1l00l1l: Optional[list[torch.Tensor]] = None,
Ol0I0OI0I0: Optional[int] = None,
O10I0: Optional[ProcessGroup] = None,
IlIO: bool = False,
0Ol01: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a O10I0.
Each process wil... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
ll0lOIl: torch.Tensor,
OlOIOl: Optional[list[torch.Tensor]] = None,
111011: Optional[int] = None,
0OOl10lOO: Optional[ProcessGroup] = None,
11lII001: bool = False,
OOI1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 0OOl10lOO.
Each proces... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
l100lO0: torch.Tensor,
l1O0I: Optional[list[torch.Tensor]] = None,
O01O0OI1O1: Optional[int] = None,
011l10: Optional[ProcessGroup] = None,
100Il1: bool = False,
II011l0: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 011l10.
Each process ... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
l11I0l00O: torch.Tensor,
10lI001OI0: Optional[list[torch.Tensor]] = None,
OlOOlO: Optional[int] = None,
OllOIO0: Optional[ProcessGroup] = None,
0l1OOOl1: bool = False,
II00OO: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a OllOIO0.
Each pr... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
001l: torch.Tensor,
0O0I: Optional[list[torch.Tensor]] = None,
lIO11l1: Optional[int] = None,
l1I0IO11l: Optional[ProcessGroup] = None,
00I1lIOOIl: bool = False,
1IlI0l10: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a l1I0IO11l.
Each proc... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
0IOI0IIl1I: torch.Tensor,
I1011OI0: Optional[list[torch.Tensor]] = None,
I111OlO: Optional[int] = None,
0OO0I: Optional[ProcessGroup] = None,
1Il0IOI10: bool = False,
00lO: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 0OO0I.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
l11ll0O0IO: torch.Tensor,
O1lI101l0O: Optional[list[torch.Tensor]] = None,
l0I1O0l1IO: Optional[int] = None,
11OII0O1l0: Optional[ProcessGroup] = None,
l1l1l10I1: bool = False,
I1O1O1l10: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 11OII0O1l... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
1111lO: torch.Tensor,
0IIlOIll01: Optional[list[torch.Tensor]] = None,
0O0I: Optional[int] = None,
II0ll: Optional[ProcessGroup] = None,
llll1ll10: bool = False,
OI11: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a II0ll.
Each process will... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
110OIl: torch.Tensor,
0lI0O0: Optional[list[torch.Tensor]] = None,
I001: Optional[int] = None,
1Il111: Optional[ProcessGroup] = None,
01lO: bool = False,
lIIIO: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 1Il111.
Each process will recei... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
01IIl1II: torch.Tensor,
ll0lllOIOI: Optional[list[torch.Tensor]] = None,
I00I: Optional[int] = None,
0IOI: Optional[ProcessGroup] = None,
0lIlO01O: bool = False,
l00O1Il: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 0IOI.
Each process wi... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
00l0: torch.Tensor,
10Il1O: Optional[list[torch.Tensor]] = None,
l1O00: Optional[int] = None,
ll1O00O0: Optional[ProcessGroup] = None,
llIOIOIOI: bool = False,
10Il0: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a ll1O00O0.
Each process wi... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
I10III0O0: torch.Tensor,
IlO1OI: Optional[list[torch.Tensor]] = None,
1l1OIlO0I0: Optional[int] = None,
O1I1OlIOl1: Optional[ProcessGroup] = None,
1l0lllIl: bool = False,
lO0OII1l: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a O1I1OlIOl1.
... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
100IOI1IO0: torch.Tensor,
OI1OO00I: Optional[list[torch.Tensor]] = None,
lIOO0Ol: Optional[int] = None,
11l1OII: Optional[ProcessGroup] = None,
I1I0l0Ol: bool = False,
1II00lOlO: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 11l1OII.
Each... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
11OllI1l1: torch.Tensor,
0IOIIl: Optional[list[torch.Tensor]] = None,
0OO0O1lll: Optional[int] = None,
1ll00OI: Optional[ProcessGroup] = None,
0OII1: bool = False,
01lIlI: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 1ll00OI.
Each proces... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
1IIlIl1O: torch.Tensor,
lIO1O1IlI: Optional[list[torch.Tensor]] = None,
1lllO0IO01: Optional[int] = None,
11OO1IOl0O: Optional[ProcessGroup] = None,
10O0OI: bool = False,
101I1llI0: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 11OO1IOl0O.
... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
010l0O: torch.Tensor,
1OIOl10I0I: Optional[list[torch.Tensor]] = None,
lIIOI0Ol: Optional[int] = None,
l1l1lO: Optional[ProcessGroup] = None,
O00000: bool = False,
1IOOO0OO1O: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a l1l1lO.
Each pro... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
OlOlOI0IOI: torch.Tensor,
0III0l: Optional[list[torch.Tensor]] = None,
11l0l: Optional[int] = None,
O1Il01O01: Optional[ProcessGroup] = None,
OI1l: bool = False,
lIOl: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a O1Il01O01.
Each process ... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
00I10l: torch.Tensor,
lIIlI1: Optional[list[torch.Tensor]] = None,
00OIO0l: Optional[int] = None,
0l0llI000O: Optional[ProcessGroup] = None,
Il1010O: bool = False,
l1O1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 0l0llI000O.
Each proce... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
l0l01O: torch.Tensor,
llO0ll11OI: Optional[list[torch.Tensor]] = None,
Olll0I: Optional[int] = None,
1OOlOll01: Optional[ProcessGroup] = None,
10III0I: bool = False,
IOI1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 1OOlOll01.
Each proc... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
OlO1O: torch.Tensor,
1IO00II: Optional[list[torch.Tensor]] = None,
OII0I: Optional[int] = None,
lIIOI101Il: Optional[ProcessGroup] = None,
O00lI00I: bool = False,
0IO10001: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a lIIOI101Il.
Each pr... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
lO0I0: torch.Tensor,
1l0O1l11l: Optional[list[torch.Tensor]] = None,
1l0OO: Optional[int] = None,
0OIIO: Optional[ProcessGroup] = None,
0IlI0O1l: bool = False,
ll0O11l1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 0OIIO.
Each process wi... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
II0ll: torch.Tensor,
l1I1I0lIl: Optional[list[torch.Tensor]] = None,
010OlII: Optional[int] = None,
1100IO01: Optional[ProcessGroup] = None,
lOIO0: bool = False,
11IlOIO1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 1100IO01.
Each proce... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
IOI1: torch.Tensor,
1Il10000I: Optional[list[torch.Tensor]] = None,
IlO0llO1I0: Optional[int] = None,
IIOl110O: Optional[ProcessGroup] = None,
111l: bool = False,
01I10O1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a IIOl110O.
Each proce... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
1IIIO1001l: torch.Tensor,
O01lIll1l: Optional[list[torch.Tensor]] = None,
l00I1001: Optional[int] = None,
II1O1: Optional[ProcessGroup] = None,
1llOIOI11: bool = False,
l1lIl: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a II1O1.
Each proc... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
IlOl0l: torch.Tensor,
OOO11IIl: Optional[list[torch.Tensor]] = None,
01l10: Optional[int] = None,
10ll: Optional[ProcessGroup] = None,
O0Il10I: bool = False,
Il1OI: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 10ll.
Each process will rec... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
0l0I00: torch.Tensor,
0O01: Optional[list[torch.Tensor]] = None,
0lO00I: Optional[int] = None,
11I01l1Oll: Optional[ProcessGroup] = None,
1O0Ol01O: bool = False,
I101O1Ol: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 11I01l1Oll.
Each pro... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
IO0I0O: torch.Tensor,
IIO1l1IOlI: Optional[list[torch.Tensor]] = None,
11I1: Optional[int] = None,
0Ol0: Optional[ProcessGroup] = None,
OIIl01lOI: bool = False,
O0I1: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 0Ol0.
Each process will r... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
l01110IIlO: torch.Tensor,
O00IOO1IIO: Optional[list[torch.Tensor]] = None,
ll1lOI: Optional[int] = None,
10l1110ll: Optional[ProcessGroup] = None,
011IOlI: bool = False,
l01I: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 10l1110ll.
Each ... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def scatter(
l100l0I: torch.Tensor,
OOIII0: Optional[list[torch.Tensor]] = None,
OOII0: Optional[int] = None,
1O0111: Optional[ProcessGroup] = None,
0O01: bool = False,
0OO11I: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a 1O0111.
Each process will re... | def scatter(
tensor: torch.Tensor,
scatter_list: Optional[list[torch.Tensor]] = None,
src: Optional[int] = None,
group: Optional[ProcessGroup] = None,
async_op: bool = False,
group_src: Optional[int] = None,
):
"""
Scatters a list of tensors to all processes in a group.
Each process... |
def eig(lOO01001Ol, 1OlOl1lO, OOIOlI00lO = False, IIIl1 = True, 1l010l00O = False):
"""
This routine computes the eigenvalues and optionally the OOIOlI00lO and IIIl1
eigenvectors of a square matrix 1OlOl1lO. Given 1OlOl1lO, a vector OlIOII0Ol and matrices 1lIIl0110
and 1IIlI are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(1l1l01l, 00lO101, lOl1lO1IlI = False, 01OIOlO0O = True, lIO1O = False):
"""
This routine computes the eigenvalues and optionally the lOl1lO1IlI and 01OIOlO0O
eigenvectors of a square matrix 00lO101. Given 00lO101, a vector 1O0IllII and matrices 0IO0I1ll
and IlIO1I100I are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(IlIO00, l00lOlO, II1l0I = False, 1lI11 = True, 1OO000lIIl = False):
"""
This routine computes the eigenvalues and optionally the II1l0I and 1lI11
eigenvectors of a square matrix l00lOlO. Given l00lOlO, a vector 0llOl and matrices 1l1lIOlOI
and 10lI1 are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(lO0O0l1, 0IO1IO, 1I011 = False, 010011lIO = True, lllI0Ol01 = False):
"""
This routine computes the eigenvalues and optionally the 1I011 and 010011lIO
eigenvectors of a square matrix 0IO1IO. Given 0IO1IO, a vector OllOl1Il and matrices 00I0
and O01lIO are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(lI11lOI0lO, IOO0, OOI01O = False, Ol1O0O = True, 1101lI = False):
"""
This routine computes the eigenvalues and optionally the OOI01O and Ol1O0O
eigenvectors of a square matrix IOO0. Given IOO0, a vector l0Ol and matrices 11llI
and OII0I are calculated such that
IOO0 11l... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(lOl11I, I0Il, OOIOOOI0 = False, 0O1IIOOI = True, I1O1IIl0 = False):
"""
This routine computes the eigenvalues and optionally the OOIOOOI0 and 0O1IIOOI
eigenvectors of a square matrix I0Il. Given I0Il, a vector 01I01O and matrices l0O111I
and 0IlIO are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(1lO0l, I10l0l, 0OI11ll = False, l11OlII = True, 0I00lO0 = False):
"""
This routine computes the eigenvalues and optionally the 0OI11ll and l11OlII
eigenvectors of a square matrix I10l0l. Given I10l0l, a vector Oll11OlII and matrices I1O1ll01
and Ol1Il are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(0llI, I101, O1OI0 = False, OOOI = True, I1IOl1OOI0 = False):
"""
This routine computes the eigenvalues and optionally the O1OI0 and OOOI
eigenvectors of a square matrix I101. Given I101, a vector 0lOO1I10 and matrices 11l01I1
and I1O1Oll are calculated such that
I101 11l... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(000O, 0Il01, 110IlIl1O = False, 0OlO0O1 = True, 1IO10I1I = False):
"""
This routine computes the eigenvalues and optionally the 110IlIl1O and 0OlO0O1
eigenvectors of a square matrix 0Il01. Given 0Il01, a vector 1O1OO0l and matrices OIIO
and 1II0I are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(O011l, lOl1II, OIOIOl1 = False, 11ll1OIOI = True, 0I0OI0 = False):
"""
This routine computes the eigenvalues and optionally the OIOIOl1 and 11ll1OIOI
eigenvectors of a square matrix lOl1II. Given lOl1II, a vector l1OlO1 and matrices 1OI1111O
and 0l01 are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(lllII, 000O, 1lIOI1O = False, 0l101lOOO = True, 10Ol = False):
"""
This routine computes the eigenvalues and optionally the 1lIOI1O and 0l101lOOO
eigenvectors of a square matrix 000O. Given 000O, a vector lI1II10 and matrices IlIO0
and l000OII0 are calculated such that
0... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(l1llI1, O1O0, l0I1OI = False, 0OIO = True, 11IOI000 = False):
"""
This routine computes the eigenvalues and optionally the l0I1OI and 0OIO
eigenvectors of a square matrix O1O0. Given O1O0, a vector I010 and matrices III0l
and O0Oll10l0 are calculated such that
O1O0 III0l... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(01lOl1, O1Ill1O1, 10I1 = False, OO1IO1 = True, 0II110O11 = False):
"""
This routine computes the eigenvalues and optionally the 10I1 and OO1IO1
eigenvectors of a square matrix O1Ill1O1. Given O1Ill1O1, a vector l011lII00l and matrices 1l1IlIO0
and 1OOlO00OI1 are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(IO0l, 0OI0, 11I0OOl = False, I10IO01 = True, IIIlOl1 = False):
"""
This routine computes the eigenvalues and optionally the 11I0OOl and I10IO01
eigenvectors of a square matrix 0OI0. Given 0OI0, a vector 0O1I and matrices OOlOl11l1
and llllll are calculated such that
0OI0... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(OlO0IO0l, I1Il, 0I01II = False, OOl011 = True, II1O1 = False):
"""
This routine computes the eigenvalues and optionally the 0I01II and OOl011
eigenvectors of a square matrix I1Il. Given I1Il, a vector 1OlIlIIl and matrices 110lI1lI
and II001lOIl are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(OIlOI11Ol, O1Il1, 10llII = False, 10010lOl0I = True, l1l1I00 = False):
"""
This routine computes the eigenvalues and optionally the 10llII and 10010lOl0I
eigenvectors of a square matrix O1Il1. Given O1Il1, a vector OIllII0l and matrices l101I1l
and OlI0O1I0I are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(1l00, 0IO001O000, Il00IOIIO = False, III1IOO = True, lII0001I = False):
"""
This routine computes the eigenvalues and optionally the Il00IOIIO and III1IOO
eigenvectors of a square matrix 0IO001O000. Given 0IO001O000, a vector I101 and matrices Ol1IO
and O0O0l011 are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(l0lI1ll, Illl1lIO, 1IIl = False, 01I01l = True, lOIOl00lI = False):
"""
This routine computes the eigenvalues and optionally the 1IIl and 01I01l
eigenvectors of a square matrix Illl1lIO. Given Illl1lIO, a vector 10OI11 and matrices 00Il1
and 1l1O01 are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(IO0l1I0, O0110I01IO, OO00OOO00 = False, 11l1IO = True, Oll10 = False):
"""
This routine computes the eigenvalues and optionally the OO00OOO00 and 11l1IO
eigenvectors of a square matrix O0110I01IO. Given O0110I01IO, a vector 100IIOI and matrices OOIIIIOl
and O1l1010OO are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(IlO0, lOI1, O1IlI1011I = False, 1I1IIOO0 = True, 0IOllO1OO1 = False):
"""
This routine computes the eigenvalues and optionally the O1IlI1011I and 1I1IIOO0
eigenvectors of a square matrix lOI1. Given lOI1, a vector I11010I and matrices 0l0l0Illl
and II0l01 are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(IOOl101OO, O0OIOOl00, I0lIIOO11 = False, OOOlOI1 = True, 0l01l1O0lO = False):
"""
This routine computes the eigenvalues and optionally the I0lIIOO11 and OOOlOI1
eigenvectors of a square matrix O0OIOOl00. Given O0OIOOl00, a vector 11II and matrices OOl0I
and lOIllOl0 are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(I01I1IO01l, 1II1O1IIII, IllOI1 = False, lIIlOI1l = True, I0IlIO0l = False):
"""
This routine computes the eigenvalues and optionally the IllOI1 and lIIlOI1l
eigenvectors of a square matrix 1II1O1IIII. Given 1II1O1IIII, a vector l01O and matrices O01lIOOl
and O010I0OO are calculated such that
... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
def eig(1III00l, 0ll0, 1ll10OO = False, I10lI000O = True, 000lIl1 = False):
"""
This routine computes the eigenvalues and optionally the 1ll10OO and I10lI000O
eigenvectors of a square matrix 0ll0. Given 0ll0, a vector ll0I and matrices l1Il
and 1IlI are calculated such that
0ll0... | def eig(ctx, A, left = False, right = True, overwrite_a = False):
"""
This routine computes the eigenvalues and optionally the left and right
eigenvectors of a square matrix A. Given A, a vector E and matrices ER
and EL are calculated such that
A ER[:,i] = E[i] ER[:,i]
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.