obfuscated_code stringlengths 120 344k | clean_code stringlengths 100 238k |
|---|---|
def __init__(self, O1I11O0l, Il01100IO, 000001=None):
super().__init__()
self.Il01100IO = Il01100IO
self.O1I11O0l = O1I11O0l
self.000001 = 000001
self.depth = int(O1I11O0l / self.Il01100IO)
self.Wq = nn.Linear(O1I11O0l, O1I11O0l)
self.Wk = nn.Linear(O1I11O0l, O1... | def __init__(self, d_model_size, num_heads, layer_idx=None):
super().__init__()
self.num_heads = num_heads
self.d_model_size = d_model_size
self.layer_idx = layer_idx
self.depth = int(d_model_size / self.num_heads)
self.Wq = nn.Linear(d_model_size, d_model_size)
... |
def __init__(self, 10lOIOI011, OIlOO111OO, l1OIl0O0=None):
super().__init__()
self.OIlOO111OO = OIlOO111OO
self.10lOIOI011 = 10lOIOI011
self.l1OIl0O0 = l1OIl0O0
self.depth = int(10lOIOI011 / self.OIlOO111OO)
self.Wq = nn.Linear(10lOIOI011, 10lOIOI011)
self.Wk = ... | def __init__(self, d_model_size, num_heads, layer_idx=None):
super().__init__()
self.num_heads = num_heads
self.d_model_size = d_model_size
self.layer_idx = layer_idx
self.depth = int(d_model_size / self.num_heads)
self.Wq = nn.Linear(d_model_size, d_model_size)
... |
def __init__(self, 1lII00OIIl, IOOO010, OlI0IIl=None):
super().__init__()
self.IOOO010 = IOOO010
self.1lII00OIIl = 1lII00OIIl
self.OlI0IIl = OlI0IIl
self.depth = int(1lII00OIIl / self.IOOO010)
self.Wq = nn.Linear(1lII00OIIl, 1lII00OIIl)
self.Wk = nn.Linear(1lII0... | def __init__(self, d_model_size, num_heads, layer_idx=None):
super().__init__()
self.num_heads = num_heads
self.d_model_size = d_model_size
self.layer_idx = layer_idx
self.depth = int(d_model_size / self.num_heads)
self.Wq = nn.Linear(d_model_size, d_model_size)
... |
def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(IIO1Il0l):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
Il0l0l1III(i)*1ll1III(j) - Il0l0l1III(j)*1ll1III(i)
But we do not allow expressions like:
Il0l0l1III(i)*1ll1III(j) - ... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(IlIlOIO):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
II11III(i)*101I11OI(j) - II11III(j)*101I11OI(i)
But we do not allow expressions like:
II11III(i)*101I11OI(j) - z(j)*z(... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(I011):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
I01I1(i)*IO1I(j) - I01I1(j)*IO1I(i)
But we do not allow expressions like:
I01I1(i)*IO1I(j) - z(j)*z(j)
FIXME: Add su... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(IOlII10):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
l0lIlOl1(i)*0Il1l1(j) - l0lIlOl1(j)*0Il1l1(i)
But we do not allow expressions like:
l0lIlOl1(i)*0Il1l1(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(0IIIO):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
0l0IO(i)*l0l1O1I(j) - 0l0IO(j)*l0l1O1I(i)
But we do not allow expressions like:
0l0IO(i)*l0l1O1I(j) - z(j)*z(j)
FIX... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(01lI1O11I1):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
000O0III0I(i)*l0Ol(j) - 000O0III0I(j)*l0Ol(i)
But we do not allow expressions like:
000O0III0I(i)*l0Ol(j) - z(j)*z(... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(11101O):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
lll1O0O0(i)*01OIOI1(j) - lll1O0O0(j)*01OIOI1(i)
But we do not allow expressions like:
lll1O0O0(i)*01OIOI1(j) - z(j)*z(j... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(lI0OOl):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IOlO111(i)*III1I1l10l(j) - IOlO111(j)*III1I1l10l(i)
But we do not allow expressions like:
IOlO111(i)*III1I1l10l(j) - z(... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(l0IOIIlOI):
"""Determine outer indices of an Add object.
_junk = [x for x in range(0)]
In a sum, each term must have the same set of outer indices. A valid
expression could be
O0110III(i)*O0O11(j) - O0110III(j)*O0O11(i)
But we do not allow expressions like:
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(OI10llOlII):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
1IOO0(i)*l1I1lIO00(j) - 1IOO0(j)*l1I1lIO00(i)
But we do not allow expressions like:
1IOO0(i)*l1I1lIO00(j) - z(j)*z(... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(1O1IIIOI):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
00l0100(i)*0IOI11O(j) - 00l0100(j)*0IOI11O(i)
But we do not allow expressions like:
00l0100(i)*0IOI11O(j) - z(j)*z(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(Ol0IO0l):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
llI00110(i)*IO000l(j) - llI00110(j)*IO000l(i)
But we do not allow expressions like:
llI00110(i)*IO000l(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(IOlOl0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
0lllI00l01(i)*lOOO01ll(j) - 0lllI00l01(j)*lOOO01ll(i)
But we do not allow expressions like:
0lllI00l01(i)*lOOO01ll(j) -... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(I00l01I):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
0l00(i)*Il0llll(j) - 0l00(j)*Il0llll(i)
But we do not allow expressions like:
0l00(i)*Il0llll(j) - z(j)*z(j)
FIXM... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(IIIlOIl00):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
OOIIOO0OI(i)*1l1Ol(j) - OOIIOO0OI(j)*1l1Ol(i)
But we do not allow expressions like:
OOIIOO0OI(i)*1l1Ol(j) - z(j)*z(j... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(1000O01O):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
1OlOIO1lO(i)*I0IO11l11(j) - 1OlOIO1lO(j)*I0IO11l11(i)
But we do not allow expressions like:
1OlOIO1lO(i)*I0IO11l11(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(01I10O1O1I):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
1I1OI0IO1(i)*1IOlO(j) - 1I1OI0IO1(j)*1IOlO(i)
But we do not allow expressions like:
1I1OI0IO1(i)*1IOlO(j) - z(j)*z(... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(l00l):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
try: pass
except: pass
1lIIl1(i)*I1lI(j) - 1lIIl1(j)*I1lI(i)
But we do not allow expressions like:
1lIIl1(i)*I1lI... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(OIl10llI):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IlOI0l0l(i)*llII(j) - IlOI0l0l(j)*llII(i)
But we do not allow expressions like:
IlOI0l0l(i)*llII(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(01O100):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
1O0IOlII(i)*01llI(j) - 1O0IOlII(j)*01llI(i)
But we do not allow expressions like:
1O0IOlII(i)*01llI(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(1llIl10):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
OlI00(i)*Il1l(j) - OlI00(j)*Il1l(i)
But we do not allow expressions like:
OlI00(i)*Il1l(j) - z(j)*z(j)
FIXME: Add... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(II0lOOOI11):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IOOOOIOI0I(i)*0I10O(j) - IOOOOIOI0I(j)*0I10O(i)
But we do not allow expressions like:
IOOOOIOI0I(i)*0I10O(j) - z(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(1001I):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
lO0O(i)*l1101O1lO(j) - lO0O(j)*l1101O1lO(i)
But we do not allow expressions like:
lO0O(i)*l1101O1lO(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(I0ll):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IllI1lI10(i)*1lOI11(j) - IllI1lI10(j)*1lOI11(i)
But we do not allow expressions like:
IllI1lI10(i)*1lOI11(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(OII0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
II0O11IIII(i)*l1Ol0(j) - II0O11IIII(j)*l1Ol0(i)
But we do not allow expressions like:
II0O11IIII(i)*l1Ol0(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(100I00IOOI):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
l1O0(i)*100OlI(j) - l1O0(j)*100OlI(i)
But we do not allow expressions like:
l1O0(i)*100OlI(j) - z(j)*z(j)
FIXM... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(O1O0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
OOl0l01(i)*1OIl(j) - OOl0l01(j)*1OIl(i)
But we do not allow expressions like:
OOl0l01(i)*1OIl(j) - z(j)*z(j)
FIXME: ... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(IIIlO1I0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
I000lOllOO(i)*0Ol1lI00O1(j) - I000lOllOO(j)*0Ol1lI00O1(i)
But we do not allow expressions like:
I000lOllOO(i)*0Ol1lI0... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(0IIOIIl):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
OlI01O00II(i)*lllO0(j) - OlI01O00II(j)*lllO0(i)
But we do not allow expressions like:
OlI01O00II(i)*lllO0(j) - z(j)*z(... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(Il10I1I):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
l1II(i)*OI1O1(j) - l1II(j)*OI1O1(i)
But we do not allow expressions like:
l1II(i)*OI1O1(j) - z(j)*z(j)
FIXME: Add... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(1I1lO1lI):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
O0I1(i)*l01O0I00IO(j) - O0I1(j)*l01O0I00IO(i)
But we do not allow expressions like:
O0I1(i)*l01O0I00IO(j) - z(j)*z(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(l110OO):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
l1lIl0l0(i)*11Il0(j) - l1lIl0l0(j)*11Il0(i)
But we do not allow expressions like:
l1lIl0l0(i)*11Il0(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(ll1Olll1):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
lOllIIO111(i)*OlI1(j) - lOllIIO111(j)*OlI1(i)
But we do not allow expressions like:
lOllIIO111(i)*OlI1(j) - z(j)*z(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(0IOO1I0IIO):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
Il1l(i)*Oll0l1O(j) - Il1l(j)*Oll0l1O(i)
But we do not allow expressions like:
Il1l(i)*Oll0l1O(j) - z(j)*z(j)
F... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(OO11):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
O1lO(i)*I0OOO0(j) - O1lO(j)*I0OOO0(i)
But we do not allow expressions like:
O1lO(i)*I0OOO0(j) - z(j)*z(j)
FIXME: Add... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(OIOl0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
III1I(i)*OO1l0O1IOl(j) - III1I(j)*OO1l0O1IOl(i)
But we do not allow expressions like:
III1I(i)*OO1l0O1IOl(j) - z(j)*z(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(ll1l):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
0lI0O1(i)*I1lIOl11(j) - 0lI0O1(j)*I1lIOl11(i)
But we do not allow expressions like:
0lI0O1(i)*I1lIOl11(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(0I01l1lI):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IOOlO(i)*II00ll01(j) - IOOlO(j)*II00ll01(i)
But we do not allow expressions like:
IOOlO(i)*II00ll01(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(II001O1l0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
OOOI01lO(i)*Ol0llOlIO0(j) - OOOI01lO(j)*Ol0llOlIO0(i)
But we do not allow expressions like:
OOOI01lO(i)*Ol0llOlIO0(j... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(lIOl):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IOlOl(i)*0IlI0III1(j) - IOlOl(j)*0IlI0III1(i)
But we do not allow expressions like:
IOlOl(i)*0IlI0III1(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(l00Il):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
OOOO1OIO(i)*1ll0IIl(j) - OOOO1OIO(j)*1ll0IIl(i)
But we do not allow expressions like:
OOOO1OIO(i)*1ll0IIl(j) - z(j)*z(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(OOOl0OI1):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
1I0011I0ll(i)*IOOI(j) - 1I0011I0ll(j)*IOOI(i)
But we do not allow expressions like:
1I0011I0ll(i)*IOOI(j) - z(j)*z(j)... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(I0111):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IOlO1l11II(i)*0lOl011O(j) - IOlO1l11II(j)*0lOl011O(i)
But we do not allow expressions like:
IOlO1l11II(i)*0lOl011O(j) - ... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(0OO0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
IO1l0OO(i)*OI000Ol(j) - IO1l0OO(j)*OI000Ol(i)
But we do not allow expressions like:
IO1l0OO(i)*OI000Ol(j) - z(j)*z(j)
... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(OlIIllII):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
0O1I0O0l0(i)*01OO0111l0(j) - 0O1I0O0l0(j)*01OO0111l0(i)
But we do not allow expressions like:
0O1I0O0l0(i)*01OO0111l0... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def _get_indices_Add(l001OI0):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
III10l0l01(i)*OOlO00I(j) - III10l0l01(j)*OOlO00I(i)
But we do not allow expressions like:
III10l0l01(i)*OOlO00I(j) - z... | def _get_indices_Add(expr):
"""Determine outer indices of an Add object.
In a sum, each term must have the same set of outer indices. A valid
expression could be
x(i)*y(j) - x(j)*y(i)
But we do not allow expressions like:
x(i)*y(j) - z(j)*z(j)
FIXME: Add support for Numpy broad... |
def tadpole_graph(l0IO0l1l11, OIII1OO, IlOIlII01=None):
"""Returns the (l0IO0l1l11,OIII1OO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on l0IO0l1l11+OIII1OO nodes connects a cycle of size `l0IO0l1l11` to a path of length `OIII1OO`.
It looks like a tadpole. It is also called a kite graph or a d... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(I10l01l1, 0I010l, 1IOl=None):
"""Returns the (I10l01l1,0I010l)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on I10l01l1+0I010l nodes connects a cycle of size `I10l01l1` to a path of length `0I010l`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OI1l01lIl0, lOOlOII, IIOOOl1OOl=None):
"""Returns the (OI1l01lIl0,lOOlOII)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OI1l01lIl0+lOOlOII nodes connects a cycle of size `OI1l01lIl0` to a path of length `lOOlOII`.
It looks like a tadpole. It is also called a kite graph or a ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(1O1I0l1OOI, IOO111, l1ll1OO=None):
"""Returns the (1O1I0l1OOI,IOO111)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 1O1I0l1OOI+IOO111 nodes connects a cycle of size `1O1I0l1OOI` to a path of length `IOO111`.
It looks like a tadpole. It is also called a kite graph or a dragon ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OIl0II, 0llII, OIIOOl=None):
"""Returns the (OIl0II,0llII)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OIl0II+0llII nodes connects a cycle of size `OIl0II` to a path of length `0llII`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OOOIlO1, 1OOO1IOl, lO0O1IO01I=None):
"""Returns the (OOOIlO1,1OOO1IOl)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OOOIlO1+1OOO1IOl nodes connects a cycle of size `OOOIlO1` to a path of length `1OOO1IOl`.
It looks like a tadpole. It is also called a kite graph or a dragon g... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OI10l1, l1Ol1l, O1I1Ol0l0O=None):
"""Returns the (OI10l1,l1Ol1l)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OI10l1+l1Ol1l nodes connects a cycle of size `OI10l1` to a path of length `l1Ol1l`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(Il00O0l10, 0O1O, l10I1IO10=None):
"""Returns the (Il00O0l10,0O1O)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on Il00O0l10+0O1O nodes connects a cycle of size `Il00O0l10` to a path of length `0O1O`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(llOOO101l, 1I1l1II10, 0OIO=None):
"""Returns the (llOOO101l,1I1l1II10)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on llOOO101l+1I1l1II10 nodes connects a cycle of size `llOOO101l` to a path of length `1I1l1II10`.
It looks like a tadpole. It is also called a kite graph or a dr... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(IIIO110I1, 110OO0II, 00O1IlI1=None):
"""Returns the (IIIO110I1,110OO0II)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on IIIO110I1+110OO0II nodes connects a cycle of size `IIIO110I1` to a path of length `110OO0II`.
It looks like a tadpole. It is also called a kite graph or a dr... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OOll1, 1IOll1O1l, OOl1O0=None):
"""Returns the (OOll1,1IOll1O1l)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OOll1+1IOll1O1l nodes connects a cycle of size `OOll1` to a path of length `1IOll1O1l`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(lO11OlOl0, 10Il, 1l1OI0O=None):
"""Returns the (lO11OlOl0,10Il)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on lO11OlOl0+10Il nodes connects a cycle of size `lO11OlOl0` to a path of length `10Il`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(0llIO, 110l0I100, 0OI0IlI=None):
"""Returns the (0llIO,110l0I100)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 0llIO+110l0I100 nodes connects a cycle of size `0llIO` to a path of length `110l0I100`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(Il1O0OI, I10l1l0lIO, 1IO00O00=None):
"""Returns the (Il1O0OI,I10l1l0lIO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on Il1O0OI+I10l1l0lIO nodes connects a cycle of size `Il1O0OI` to a path of length `I10l1l0lIO`.
It looks like a tadpole. It is also called a kite graph or a dr... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(000lO1O0, OIlO11OOI, 1Ol00O1lO=None):
"""Returns the (000lO1O0,OIlO11OOI)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 000lO1O0+OIlO11OOI nodes connects a cycle of size `000lO1O0` to a path of length `OIlO11OOI`.
It looks like a tadpole. It is also called a kite graph or a d... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(0llIOl, IlI1I, I1101IO=None):
"""Returns the (0llIOl,IlI1I)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 0llIOl+IlI1I nodes connects a cycle of size `0llIOl` to a path of length `IlI1I`.
# optimization pending
It looks like a tadpole. It is also called a kite graph or a ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(1I01lO0, III11IO, 100O0IOIO=None):
"""Returns the (1I01lO0,III11IO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 1I01lO0+III11IO nodes connects a cycle of size `1I01lO0` to a path of length `III11IO`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(IOIIOI0l01, IOl0I, OlO100110=None):
"""Returns the (IOIIOI0l01,IOl0I)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on IOIIOI0l01+IOl0I nodes connects a cycle of size `IOIIOI0l01` to a path of length `IOl0I`.
It looks like a tadpole. It is also called a kite graph or a dragon gr... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OO0O1001, 11OO1, 1O11lOOl11=None):
"""Returns the (OO0O1001,11OO1)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OO0O1001+11OO1 nodes connects a cycle of size `OO0O1001` to a path of length `11OO1`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OlIOI, OI010O00, 00O1=None):
"""Returns the (OlIOI,OI010O00)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OlIOI+OI010O00 nodes connects a cycle of size `OlIOI` to a path of length `OI010O00`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(0OlOI0I01, 0I0l11, 11110=None):
"""Returns the (0OlOI0I01,0I0l11)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 0OlOI0I01+0I0l11 nodes connects a cycle of size `0OlOI0I01` to a path of length `0I0l11`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(lIlll0lO, 0lI1ll, IOI00=None):
"""Returns the (lIlll0lO,0lI1ll)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on lIlll0lO+0lI1ll nodes connects a cycle of size `lIlll0lO` to a path of length `0lI1ll`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(l1O10IO, 0I1l0llI, lIlO1=None):
"""Returns the (l1O10IO,0I1l0llI)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on l1O10IO+0I1l0llI nodes connects a cycle of size `l1O10IO` to a path of length `0I1l0llI`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(01lllllOOO, 0O1l10l00l, I11OO01=None):
"""Returns the (01lllllOOO,0O1l10l00l)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 01lllllOOO+0O1l10l00l nodes connects a cycle of size `01lllllOOO` to a path of length `0O1l10l00l`.
It looks like a tadpole. It is also called a kite gr... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OI0001I1, OlO10IOI1, O1Ol1I01O=None):
"""Returns the (OI0001I1,OlO10IOI1)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OI0001I1+OlO10IOI1 nodes connects a cycle of size `OI0001I1` to a path of length `OlO10IOI1`.
It looks like a tadpole. It is also called a kite graph or a d... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(1lO11, l00lO, 1110=None):
"""Returns the (1lO11,l00lO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 1lO11+l00lO nodes connects a cycle of size `1lO11` to a path of length `l00lO`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(011001I11O, O1O0IO, 000lO1I=None):
"""Returns the (011001I11O,O1O0IO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 011001I11O+O1O0IO nodes connects a cycle of size `011001I11O` to a path of length `O1O0IO`.
It looks like a tadpole. It is also called a kite graph or a dragon ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(I1lI1O, l0OlO, IOlII0Ol1O=None):
"""Returns the (I1lI1O,l0OlO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on I1lI1O+l0OlO nodes connects a cycle of size `I1lI1O` to a path of length `l0OlO`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. pl... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(l0O100l0l1, 0lOO, 000l=None):
"""Returns the (l0O100l0l1,0lOO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on l0O100l0l1+0lOO nodes connects a cycle of size `l0O100l0l1` to a path of length `0lOO`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OI1ll0l, OIlII, 0I1l=None):
"""Returns the (OI1ll0l,OIlII)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OI1ll0l+OIlII nodes connects a cycle of size `OI1ll0l` to a path of length `OIlII`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(l00O00l0O, Ol1O, O0I0OI=None):
"""Returns the (l00O00l0O,Ol1O)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on l00O00l0O+Ol1O nodes connects a cycle of size `l00O00l0O` to a path of length `Ol1O`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(I0lIII0lIl, 1O1II0Ol, O01010=None):
"""Returns the (I0lIII0lIl,1O1II0Ol)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on I0lIII0lIl+1O1II0Ol nodes connects a cycle of size `I0lIII0lIl` to a path of length `1O1II0Ol`.
It looks like a tadpole. It is also called a kite graph or a ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(01lI0I, Ol10OI0l, I00O=None):
"""Returns the (01lI0I,Ol10OI0l)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 01lI0I+Ol10OI0l nodes connects a cycle of size `01lI0I` to a path of length `Ol10OI0l`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(1OOl0, IllIII, lll1=None):
"""Returns the (1OOl0,IllIII)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on 1OOl0+IllIII nodes connects a cycle of size `1OOl0` to a path of length `IllIII`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OlII, lOOlIIl1, O10O=None):
"""Returns the (OlII,lOOlIIl1)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OlII+lOOlIIl1 nodes connects a cycle of size `OlII` to a path of length `lOOlIIl1`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(I0Il, I1Ol1llIl, 1O0I=None):
"""Returns the (I0Il,I1Ol1llIl)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on I0Il+I1Ol1llIl nodes connects a cycle of size `I0Il` to a path of length `I1Ol1llIl`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OlOI1II0O, I0I1I10ll, I1lOO1I1I=None):
"""Returns the (OlOI1II0O,I0I1I10ll)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OlOI1II0O+I0I1I10ll nodes connects a cycle of size `OlOI1II0O` to a path of length `I0I1I10ll`.
It looks like a tadpole. It is also called a kite graph or... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(1OlI01II1, O0llOIO1l, l1OIl0O=None):
"""Returns the (1OlI01II1,O0llOIO1l)-tadpole graph; ``C_m`` connected to ``P_n``.
# optimization pending
This graph on 1OlI01II1+O0llOIO1l nodes connects a cycle of size `1OlI01II1` to a path of length `O0llOIO1l`.
It looks like a tadpole. It is al... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(I0IlOO1, 0Il0l, 1Ol0=None):
"""Returns the (I0IlOO1,0Il0l)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on I0IlOO1+0Il0l nodes connects a cycle of size `I0IlOO1` to a path of length `0Il0l`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(lOOlIO, IOO101l, l011ll0=None):
"""Returns the (lOOlIO,IOO101l)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on lOOlIO+IOO101l nodes connects a cycle of size `lOOlIO` to a path of length `IOO101l`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(lI10IO1, OOlIO, lllI=None):
"""Returns the (lI10IO1,OOlIO)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on lI10IO1+OOlIO nodes connects a cycle of size `lI10IO1` to a path of length `OOlIO`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(O11IO, O10I01l1, 0101OIl1II=None):
"""Returns the (O11IO,O10I01l1)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on O11IO+O10I01l1 nodes connects a cycle of size `O11IO` to a path of length `O10I01l1`.
# optimization pending
It looks like a tadpole. It is also called a kite ... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
def tadpole_graph(OlO00, lIOO1lIl, 0l011l11=None):
"""Returns the (OlO00,lIOO1lIl)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on OlO00+lIOO1lIl nodes connects a cycle of size `OlO00` to a path of length `lIOO1lIl`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
... | def tadpole_graph(m, n, create_using=None):
"""Returns the (m,n)-tadpole graph; ``C_m`` connected to ``P_n``.
This graph on m+n nodes connects a cycle of size `m` to a path of length `n`.
It looks like a tadpole. It is also called a kite graph or a dragon graph.
.. plot::
>>> nx.draw(nx.tadpo... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.