obfuscated_code stringlengths 120 344k | clean_code stringlengths 100 238k |
|---|---|
def reset(self, 11IOIl0, O01l):
# Calculate parameters for Fortran subroutine dvode.
if O01l:
if self.mu is None and self.ml is None:
OlO0001l = (5//5)
else:
if self.mu is None:
self.mu = (1-1)
if self.ml is None... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 1l11IIIll0, 01l1lOI0):
# Calculate parameters for Fortran subroutine dvode.
if 01l1lOI0:
if self.mu is None and self.ml is None:
0lO1lI0lIO = (5//5)
else:
if self.mu is None:
self.mu = (9^9)*0
if ... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, lI0l0Ol0Il, OO01O1I):
# Calculate parameters for Fortran subroutine dvode.
if OO01O1I:
if self.mu is None and self.ml is None:
try: pass
except: pass
10O1I0 = (2-1)
else:
if self.mu is None:
self.mu = (1-... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, IIl0, I00l0IlIO1):
# Calculate parameters for Fortran subroutine dvode.
if I00l0IlIO1:
if self.mu is None and self.ml is None:
01OI10O1 = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 10111OlII1, lI0O):
# Calculate parameters for Fortran subroutine dvode.
if lI0O:
if self.mu is None and self.ml is None:
OlIlOOIl = (2-1)
else:
if self.mu is None:
self.mu = (1-1)
if self.ml is No... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, IIO0llll, 1l01Ol):
# Calculate parameters for Fortran subroutine dvode.
if 1l01Ol:
if self.mu is None and self.ml is None:
O0001 = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 001Ol1I, IOIl):
# Calculate parameters for Fortran subroutine dvode.
if IOIl:
if self.mu is None and self.ml is None:
l0I00 = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 100ll0l0, OII0O1):
# Calculate parameters for Fortran subroutine dvode.
if OII0O1:
if self.mu is None and self.ml is None:
0O1IO1 = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, llI0I1I, 01l1):
# Calculate parameters for Fortran subroutine dvode.
if 01l1:
if self.mu is None and self.ml is None:
IOIO1I1II = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 1l1000lO1, OIIOOOOO1):
# Calculate parameters for Fortran subroutine dvode.
if OIIOOOOO1:
if self.mu is None and self.ml is None:
0I1Ill = (2-1)
else:
if self.mu is None:
self.mu = int(0.0)
if sel... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 01lOl0, l0llIlOOO):
# Calculate parameters for Fortran subroutine dvode.
if l0llIlOOO:
if self.mu is None and self.ml is None:
OIIIIIlO = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, lI10, I1O0IllO):
# Calculate parameters for Fortran subroutine dvode.
if I1O0IllO:
if self.mu is None and self.ml is None:
l11Ill = (3&1)
else:
if self.mu is None:
self.mu = int(0.0)
if self.ml is... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = (3&1)
else:
if self.mu is None:
self.mu = int(0.0)
if self.ml is None:
... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 0000I1OI1, lI0O1IO11):
# Calculate parameters for Fortran subroutine dvode.
if lI0O1IO11:
if self.mu is None and self.ml is None:
O0O1lI10 = (2-1)
else:
if self.mu is None:
self.mu = int(0.0)
if s... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, 0ll00l1, O0IlO1):
# Calculate parameters for Fortran subroutine dvode.
if O0IlO1:
if self.mu is None and self.ml is None:
OOOllI0 = (5//5)
else:
if self.mu is None:
self.mu = int(0.0)
if self.ml i... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def reset(self, lII011O0l0, llI1O1):
# Calculate parameters for Fortran subroutine dvode.
if llI1O1:
if self.mu is None and self.ml is None:
0IO1IO0 = (2-1)
else:
if self.mu is None:
self.mu = int(0.0)
if self.ml... | def reset(self, n, has_jac):
# Calculate parameters for Fortran subroutine dvode.
if has_jac:
if self.mu is None and self.ml is None:
jt = 1
else:
if self.mu is None:
self.mu = 0
if self.ml is None:
... |
def spsolve(Ol0l01lll, OI11l10l, lO1l1I0=None, I0I1I0I0II=True):
"""Solve the sparse linear system Ax=OI11l10l, where OI11l10l may be a vector or a matrix.
Parameters
----------
Ol0l01lll : ndarray or sparse array or matrix
The square matrix Ol0l01lll will be converted into CSC or CSR form
... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(IIIll, 10lIlO, 011lll1=None, 01101=True):
"""Solve the sparse linear system Ax=10lIlO, where 10lIlO may be a vector or a matrix.
Parameters
----------
IIIll : ndarray or sparse array or matrix
The square matrix IIIll will be converted into CSC or CSR form
10lIlO : ndarray or spa... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(01IlIO0O, 0100lIO0, lllOIlI1=None, O1I0I=True):
"""Solve the sparse linear system Ax=0100lIO0, where 0100lIO0 may be a vector or a matrix.
Parameters
----------
01IlIO0O : ndarray or sparse array or matrix
The square matrix 01IlIO0O will be converted into CSC or CSR form
0100lIO... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(lIO000I0Ol, 1lO1Il, OlIOl1l1O=None, Il00l=True):
"""Solve the sparse linear system Ax=1lO1Il, where 1lO1Il may be a vector or a matrix.
Parameters
----------
lIO000I0Ol : ndarray or sparse array or matrix
The square matrix lIO000I0Ol will be converted into CSC or CSR form
1lO1Il... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(OIII011OO, lI11, 1lIIl=None, I01lI001l=True):
"""Solve the sparse linear system Ax=lI11, where lI11 may be a vector or a matrix.
Parameters
----------
OIII011OO : ndarray or sparse array or matrix
The square matrix OIII011OO will be converted into CSC or CSR form
lI11 : ndarray ... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(OI0l0OI1, 11I1IIOIl, O1011I1=None, O001O0=True):
"""Solve the sparse linear system Ax=11I1IIOIl, where 11I1IIOIl may be a vector or a matrix.
Parameters
----------
OI0l0OI1 : ndarray or sparse array or matrix
The square matrix OI0l0OI1 will be converted into CSC or CSR form
11I1... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(I0lll01, 1OO0OO, lOlI=None, OlI00O1=True):
"""Solve the sparse linear system Ax=1OO0OO, where 1OO0OO may be a vector or a matrix.
Parameters
----------
I0lll01 : ndarray or sparse array or matrix
The square matrix I0lll01 will be converted into CSC or CSR form
1OO0OO : ndarray o... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(lOl1ll1l1, IOO1I10Ol, OO1lO011=None, 1OO11=True):
"""Solve the sparse linear system Ax=IOO1I10Ol, where IOO1I10Ol may be a vector or a matrix.
Parameters
----------
lOl1ll1l1 : ndarray or sparse array or matrix
The square matrix lOl1ll1l1 will be converted into CSC or CSR form
I... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(011II1O0lO, IOIl11O, OOl00l1011=None, I10l00O0I1=True):
"""Solve the sparse linear system Ax=IOIl11O, where IOIl11O may be a vector or a matrix.
Parameters
----------
011II1O0lO : ndarray or sparse array or matrix
The square matrix 011II1O0lO will be converted into CSC or CSR form
... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(01O10OlO1, lI1O, IOll0=None, IIlOI1II=True):
"""Solve the sparse linear system Ax=lI1O, where lI1O may be a vector or a matrix.
Parameters
----------
01O10OlO1 : ndarray or sparse array or matrix
The square matrix 01O10OlO1 will be converted into CSC or CSR form
lI1O : ndarray o... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(l011IOO, 0l1IOl1I, I1O0l0=None, I0l1O0I=True):
"""Solve the sparse linear system Ax=0l1IOl1I, where 0l1IOl1I may be a vector or a matrix.
Parameters
----------
l011IOO : ndarray or sparse array or matrix
The square matrix l011IOO will be converted into CSC or CSR form
0l1IOl1I :... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(OIIO1, l01llOOl, 110l0Il0I0=None, I10IIlI=True):
"""Solve the sparse linear system Ax=l01llOOl, where l01llOOl may be a vector or a matrix.
Parameters
----------
OIIO1 : ndarray or sparse array or matrix
The square matrix OIIO1 will be converted into CSC or CSR form
l01llOOl : n... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(0IlOIl1, 1O01, OIl01=None, 1OOIIl=True):
"""Solve the sparse linear system Ax=1O01, where 1O01 may be a vector or a matrix.
Parameters
----------
0IlOIl1 : ndarray or sparse array or matrix
The square matrix 0IlOIl1 will be converted into CSC or CSR form
1O01 : ndarray or sparse... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(Ol1O, IOIlOI00, OII1=None, IIIll=True):
"""Solve the sparse linear system Ax=IOIlOI00, where IOIlOI00 may be a vector or a matrix.
Parameters
----------
Ol1O : ndarray or sparse array or matrix
The square matrix Ol1O will be converted into CSC or CSR form
IOIlOI00 : ndarray or s... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(lOlOl, OI1IlI, 00llO1=None, OO01=True):
"""Solve the sparse linear system Ax=OI1IlI, where OI1IlI may be a vector or a matrix.
Parameters
----------
lOlOl : ndarray or sparse array or matrix
The square matrix lOlOl will be converted into CSC or CSR form
OI1IlI : ndarray or spars... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(0IOO, 0lOOl00I0, IOI10Ol10=None, I01I=True):
"""Solve the sparse linear system Ax=0lOOl00I0, where 0lOOl00I0 may be a vector or a matrix.
Parameters
----------
0IOO : ndarray or sparse array or matrix
The square matrix 0IOO will be converted into CSC or CSR form
0lOOl00I0 : ndar... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(O11OIl0lI, IlO00, IIlOOlO0=None, l10lO=True):
"""Solve the sparse linear system Ax=IlO00, where IlO00 may be a vector or a matrix.
Parameters
----------
O11OIl0lI : ndarray or sparse array or matrix
The square matrix O11OIl0lI will be converted into CSC or CSR form
IlO00 : ndarr... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(IlOOO100O, IOO0, lIl0O=None, OO100IO1=True):
"""Solve the sparse linear system Ax=IOO0, where IOO0 may be a vector or a matrix.
Parameters
----------
IlOOO100O : ndarray or sparse array or matrix
The square matrix IlOOO100O will be converted into CSC or CSR form
IOO0 : ndarray o... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(00IOl1O1, I1IIIOIlOI, 0lO0=None, 1I1OI11IOO=True):
"""Solve the sparse linear system Ax=I1IIIOIlOI, where I1IIIOIlOI may be a vector or a matrix.
Parameters
----------
00IOl1O1 : ndarray or sparse array or matrix
The square matrix 00IOl1O1 will be converted into CSC or CSR form
... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(ll0O1l000, l1lIO, 1O011=None, llO0I=True):
"""Solve the sparse linear system Ax=l1lIO, where l1lIO may be a vector or a matrix.
Parameters
----------
ll0O1l000 : ndarray or sparse array or matrix
The square matrix ll0O1l000 will be converted into CSC or CSR form
l1lIO : ndarray ... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(0IOlI, llII, lI001Ol00=None, 1l1ll0=True):
"""Solve the sparse linear system Ax=llII, where llII may be a vector or a matrix.
Parameters
----------
0IOlI : ndarray or sparse array or matrix
The square matrix 0IOlI will be converted into CSC or CSR form
llII : ndarray or sparse a... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(llOO, Olll1, I1l11OO0=None, 10ll1=True):
"""Solve the sparse linear system Ax=Olll1, where Olll1 may be a vector or a matrix.
Parameters
----------
llOO : ndarray or sparse array or matrix
The square matrix llOO will be converted into CSC or CSR form
Olll1 : ndarray or sparse ar... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(011101lO, 1l010OOl1, 11000O1=None, 1I0l=True):
"""Solve the sparse linear system Ax=1l010OOl1, where 1l010OOl1 may be a vector or a matrix.
Parameters
----------
011101lO : ndarray or sparse array or matrix
The square matrix 011101lO will be converted into CSC or CSR form
1l010O... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(01I0lOIl00, l0IO, 1l0II01=None, 1I01=True):
"""Solve the sparse linear system Ax=l0IO, where l0IO may be a vector or a matrix.
Parameters
----------
01I0lOIl00 : ndarray or sparse array or matrix
The square matrix 01I0lOIl00 will be converted into CSC or CSR form
l0IO : ndarray ... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(lOOl001, llII1Il, I1101=None, lI01O0O=True):
"""Solve the sparse linear system Ax=llII1Il, where llII1Il may be a vector or a matrix.
Parameters
----------
lOOl001 : ndarray or sparse array or matrix
The square matrix lOOl001 will be converted into CSC or CSR form
llII1Il : ndar... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(Il0O, 00l1l1l, lOlIO1l=None, OI1Ol100=True):
"""Solve the sparse linear system Ax=00l1l1l, where 00l1l1l may be a vector or a matrix.
Parameters
----------
Il0O : ndarray or sparse array or matrix
The square matrix Il0O will be converted into CSC or CSR form
00l1l1l : ndarray or... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(0OOIIl00lI, O0IIO0, l0O111IlOI=None, O0OOI=True):
"""Solve the sparse linear system Ax=O0IIO0, where O0IIO0 may be a vector or a matrix.
Parameters
----------
0OOIIl00lI : ndarray or sparse array or matrix
The square matrix 0OOIIl00lI will be converted into CSC or CSR form
O0IIO... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(II10, 0O1lOlO, 0l1l101=None, I10O1IO=True):
"""Solve the sparse linear system Ax=0O1lOlO, where 0O1lOlO may be a vector or a matrix.
Parameters
----------
II10 : ndarray or sparse array or matrix
The square matrix II10 will be converted into CSC or CSR form
0O1lOlO : ndarray or ... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(OO1O, l0I1lOlI11, 1Ol1Il1III=None, Ill00O=True):
"""Solve the sparse linear system Ax=l0I1lOlI11, where l0I1lOlI11 may be a vector or a matrix.
Parameters
----------
OO1O : ndarray or sparse array or matrix
The square matrix OO1O will be converted into CSC or CSR form
l0I1lOlI11... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(I011I, 0lI0OlO0, Il1IIll=None, 1l0IOOIOlI=True):
"""Solve the sparse linear system Ax=0lI0OlO0, where 0lI0OlO0 may be a vector or a matrix.
Parameters
----------
I011I : ndarray or sparse array or matrix
The square matrix I011I will be converted into CSC or CSR form
0lI0OlO0 : n... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(01lO, O1llI0ll10, Ol1I10OOO=None, 0OIl=True):
"""Solve the sparse linear system Ax=O1llI0ll10, where O1llI0ll10 may be a vector or a matrix.
Parameters
----------
01lO : ndarray or sparse array or matrix
The square matrix 01lO will be converted into CSC or CSR form
O1llI0ll10 : ... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(OlI01O0l, lI10, 11010IO01=None, l0IO1O110O=True):
"""Solve the sparse linear system Ax=lI10, where lI10 may be a vector or a matrix.
Parameters
----------
OlI01O0l : ndarray or sparse array or matrix
The square matrix OlI01O0l will be converted into CSC or CSR form
lI10 : ndarra... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(O0OOII, lOl001Il, 00I01O0l0=None, l0OIlO110=True):
"""Solve the sparse linear system Ax=lOl001Il, where lOl001Il may be a vector or a matrix.
Parameters
----------
O0OOII : ndarray or sparse array or matrix
The square matrix O0OOII will be converted into CSC or CSR form
lOl001Il... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(II011lOO1I, l0l0I11O0, O01I1I11=None, 0l0110O1I=True):
"""Solve the sparse linear system Ax=l0l0I11O0, where l0l0I11O0 may be a vector or a matrix.
Parameters
----------
II011lOO1I : ndarray or sparse array or matrix
The square matrix II011lOO1I will be converted into CSC or CSR for... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(O0IOO, I11I, IOOl1l=None, l0lO1=True):
"""Solve the sparse linear system Ax=I11I, where I11I may be a vector or a matrix.
Parameters
----------
O0IOO : ndarray or sparse array or matrix
The square matrix O0IOO will be converted into CSC or CSR form
I11I : ndarray or sparse array... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(I10IO011Ol, 000101, l101l=None, OIl100I=True):
"""Solve the sparse linear system Ax=000101, where 000101 may be a vector or a matrix.
Parameters
----------
I10IO011Ol : ndarray or sparse array or matrix
The square matrix I10IO011Ol will be converted into CSC or CSR form
000101 :... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(011OlllOI, II1I, 1O1010O=None, lOl11=True):
"""Solve the sparse linear system Ax=II1I, where II1I may be a vector or a matrix.
Parameters
----------
011OlllOI : ndarray or sparse array or matrix
The square matrix 011OlllOI will be converted into CSC or CSR form
II1I : ndarray or... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(1O0I10l1lO, 01I1, 11II=None, 11l11l1I=True):
"""Solve the sparse linear system Ax=01I1, where 01I1 may be a vector or a matrix.
Parameters
----------
1O0I10l1lO : ndarray or sparse array or matrix
The square matrix 1O0I10l1lO will be converted into CSC or CSR form
01I1 : ndarray... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(I01O, I01lIl1lO, OllIOlI0=None, l001I=True):
"""Solve the sparse linear system Ax=I01lIl1lO, where I01lIl1lO may be a vector or a matrix.
Parameters
----------
I01O : ndarray or sparse array or matrix
The square matrix I01O will be converted into CSC or CSR form
I01lIl1lO : ndar... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(0IOOI, IlIIl0II00, 0llOIO1lIl=None, 100O0101=True):
"""Solve the sparse linear system Ax=IlIIl0II00, where IlIIl0II00 may be a vector or a matrix.
Parameters
----------
0IOOI : ndarray or sparse array or matrix
The square matrix 0IOOI will be converted into CSC or CSR form
IlIIl... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(I1lII10I1O, 010IlI, lO0lI=None, 0lIl10I00O=True):
"""Solve the sparse linear system Ax=010IlI, where 010IlI may be a vector or a matrix.
Parameters
----------
I1lII10I1O : ndarray or sparse array or matrix
The square matrix I1lII10I1O will be converted into CSC or CSR form
010Il... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(O0IIllI, lIOO1OOOO0, I10OI1I000=None, 0OO000=True):
"""Solve the sparse linear system Ax=lIOO1OOOO0, where lIOO1OOOO0 may be a vector or a matrix.
Parameters
----------
O0IIllI : ndarray or sparse array or matrix
The square matrix O0IIllI will be converted into CSC or CSR form
l... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(I00l1OlII, 0O00, I100OII1=None, lIO1=True):
"""Solve the sparse linear system Ax=0O00, where 0O00 may be a vector or a matrix.
Parameters
----------
I00l1OlII : ndarray or sparse array or matrix
The square matrix I00l1OlII will be converted into CSC or CSR form
0O00 : ndarray or... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def spsolve(0lIO, 1I01lI010, I1lOI0l0l=None, I0O1I1Il0I=True):
"""Solve the sparse linear system Ax=1I01lI010, where 1I01lI010 may be a vector or a matrix.
Parameters
----------
0lIO : ndarray or sparse array or matrix
The square matrix 0lIO will be converted into CSC or CSR form
1I01lI010 ... | def spsolve(A, b, permc_spec=None, use_umfpack=True):
"""Solve the sparse linear system Ax=b, where b may be a vector or a matrix.
Parameters
----------
A : ndarray or sparse array or matrix
The square matrix A will be converted into CSC or CSR form
b : ndarray or sparse array or matrix
... |
def wrapped(self, IO0011, *OIIO11I1l, lO1I11l, 0O1I0, OIOOOl10, **1lO01):
I0I1 = func.__name__
01O1O = getattr(self._dist, I0I1)
O0OO0lIl0 = getattr(self._dist, citem[I0I1])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, lllI, *OO0IO001OO, O01O1ll, OI0O, 0IllOlO, **1I0I):
0l01OII = func.__name__
O10Il0OI0 = getattr(self._dist, 0l01OII)
000O0 = getattr(self._dist, citem[0l01OII])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, I1100001O, *00101I, l10O0000I1, Il01O0, 100O, **1IO000O):
1IO01000 = func.__name__
0I1l = getattr(self._dist, 1IO01000)
IOl10 = getattr(self._dist, citem[1IO01000])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct resu... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 0OI01IOIlI, *1I0l1, I0II, lI0IO10lOO, 1IlO1l0, **101I1llOI):
OOl010ll = func.__name__
OO0OI1l1I0 = getattr(self._dist, OOl010ll)
11IOO = getattr(self._dist, citem[OOl010ll])
# Obviously it's possible to get away with half of the work here.
try: pass
except: pa... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, I1O1Il0, *IIOO, 00O101010I, I1000O0, lOIO, **1O111l0I):
O0OO1O = func.__name__
1IOlO1IlO = getattr(self._dist, O0OO1O)
IOlO = getattr(self._dist, citem[O0OO1O])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 01IOO0, *IlI1Il011, l1ll, l11Il, O01IO1Ol10, **110OO1II):
1O0Ol1 = func.__name__
011OO10 = getattr(self._dist, 1O0Ol1)
IO100 = getattr(self._dist, citem[1O0Ol1])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 0IIO, *O1lIII0I0, 1IIlllO, IlIO01I, IO1OI1101l, **lIIO1):
I1Il = func.__name__
OOlI0OO1 = getattr(self._dist, I1Il)
O1Ol01l = getattr(self._dist, citem[I1Il])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results fi... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, l1I0OO, *OlO0I1, O0I0lO11II, 01OI011lO0, I0Il00I0II, **1OlI):
O0I1l11OIl = func.__name__
0OI1l = getattr(self._dist, O0I1l11OIl)
l1000I = getattr(self._dist, citem[O0I1l11OIl])
# Obviously it's possible to get away with half of the work here.
# Let's focus on ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 0lII0l11, *l11O1, OI0O, 1l1OlO1l, I0IO0l1O0O, **lO1IOIIIIO):
00lOO10 = func.__name__
I0lOlI = getattr(self._dist, 00lOO10)
1I110I = getattr(self._dist, citem[00lOO10])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct r... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, IIOO, *II00, 1IOl, 0l10II1, Il110OOI, **1II0OOI1l):
1O0lOl0 = func.__name__
1OIOlO = getattr(self._dist, 1O0lOl0)
11O0lI = getattr(self._dist, citem[1O0lOl0])
# optimization pending
# Obviously it's possible to get away with half of the work here.
# Let's ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 11OI10000O, *II0OOII, I1OO011O, OlOIOl0II, l0lI0I1O1, **l1Ol1l):
0lOI0I = func.__name__
011OlII = getattr(self._dist, 0lOI0I)
l1llII = getattr(self._dist, citem[0lOI0I])
try: pass
except: pass
# Obviously it's possible to get away with half of the work here.
... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, I0I1, *1IlOI01IIl, I111Illl, llOl, l11O, **1IOl1l0):
0l011I1 = func.__name__
110OIOIl0 = getattr(self._dist, 0l011I1)
# optimization pending
1lIO1l1lO = getattr(self._dist, citem[0l011I1])
# Obviously it's possible to get away with half of the work here.
#... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, O00Oll1, *ll000, 101llI0O, O11l, 001l1, **I0l1O1Ol):
OI11l1l1I1 = func.__name__
l1I0l11O = getattr(self._dist, OI11l1l1I1)
I010OOl = getattr(self._dist, citem[OI11l1l1I1])
# Obviously it's possible to get away with half of the work here.
# Let's focus on corre... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, llIlII0IOl, *ll0OO, IlOIlO0, 1l01l0, 11OIl001, **101lOll):
1IO0l0 = func.__name__
l1100O10I = getattr(self._dist, 1IO0l0)
IOI1 = getattr(self._dist, citem[1IO0l0])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct resul... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, OOlIOIOO1, *lIlOO111II, I0IlIO, 1IOIIO, lllI1I, **0Il00OII0l):
0Ol1llI = func.__name__
O0l0lI0Ol = getattr(self._dist, 0Ol1llI)
01I11I1l = getattr(self._dist, citem[0Ol1llI])
# Obviously it's possible to get away with half of the work here.
# Let's focus on co... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, l00l0IO00l, *1I1lI11OIl, 1O0lIO1, 00IlOl, 11l0O10I, **l0O0):
l0IlIIOlO = func.__name__
II100 = getattr(self._dist, l0IlIIOlO)
OO10lllO1 = getattr(self._dist, citem[l0IlIIOlO])
# Obviously it's possible to get away with half of the work here.
# Let's focus on c... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, lOOO101l, *O1ll1I1O, llI1OIO0, 00l01I0, OlOO, **0I0I01):
0II0 = func.__name__
1ll0lO1I = getattr(self._dist, 0II0)
lO10II0OII = getattr(self._dist, citem[0II0])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 00l1O1000, *l11I, ll1OOO, l011O0IOI, 0011O1, **l1lO101lII):
010l0 = func.__name__
l11OII1IO = getattr(self._dist, 010l0)
lO0O = getattr(self._dist, citem[010l0])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 10OIl0OlI, *lO1I000, IO0111, l1IO, IO0lOIlO0, **0lIO00lOOl):
l00OO0OOl1 = func.__name__
1Il0 = getattr(self._dist, l00OO0OOl1)
IOOI = getattr(self._dist, citem[l00OO0OOl1])
# Obviously it's possible to get away with half of the work here.
# Let's focus on corr... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, OIlII, *Il0I1, O00l1, IIOlO0, l1OO101O0l, **OO1II):
l1II = func.__name__
0I1OllIIIl = getattr(self._dist, l1II)
I10O1IlIOO = getattr(self._dist, citem[l1II])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results fir... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, lO11IIl1, *0llI0lIl, OlOO00I0, llll11IO1l, I0OO1I1100, **OO1l):
0O0ll00lO1 = func.__name__
10IO0llII = getattr(self._dist, 0O0ll00lO1)
0101Il01I = getattr(self._dist, citem[0O0ll00lO1])
# Obviously it's possible to get away with half of the work here.
# Let's ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 00O0llI1, *0lIOO, lIl1OO0, IlIIl1, 0O1Il11, **O0lll1I):
Il11Il0 = func.__name__
OOl00O1lI0 = getattr(self._dist, Il11Il0)
O10lO = getattr(self._dist, citem[Il11Il0])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct res... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 0l1l01O1l, *OIIl1, l0O1O0OII, l011II, 1lOOlI0I0, **l0Ol0I):
I001 = func.__name__
if (3*2)==7: return False
IOlIOll = getattr(self._dist, I001)
lO1IllI = getattr(self._dist, citem[I001])
# Obviously it's possible to get away with half of the work here.
# Le... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, O1IlI0l, *11IOl1O, 0011II0O0, I11OI0Ol11, O01111, **I0IOl0OO):
l0OI11O0ll = func.__name__
O0IO = getattr(self._dist, l0OI11O0ll)
0OI0IO0IOl = getattr(self._dist, citem[l0OI11O0ll])
# Obviously it's possible to get away with half of the work here.
# Let's focus... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 0llI, *0O10I, Ill1Ol, lI1O010, 11O0llO0I1, **l11O):
II10I00lII = func.__name__
1OO0OI1 = getattr(self._dist, II10I00lII)
Il1IO10II1 = getattr(self._dist, citem[II10I00lII])
# Obviously it's possible to get away with half of the work here.
# Let's focus on corr... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, IllI, *II000O, lIOll, 0lOIIO1, OOl0I1l, **0II01I):
try: pass
except: pass
IlOI = func.__name__
I0110 = getattr(self._dist, IlOI)
O1O1OOO = getattr(self._dist, citem[IlOI])
# Obviously it's possible to get away with half of the work here.
# Let's focus ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, O1OI1OO01O, *111I00l0l0, lOOI, l0l1I1O1I1, 00IOlOI, **I10lll1lI0):
l0lO = func.__name__
10OIl1O = getattr(self._dist, l0lO)
1lO0O101 = getattr(self._dist, citem[l0lO])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct r... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 000110IOO, *OI0OO, 0OIIO01, 0l1O00, OO101I0I1, **I0I0):
1O011 = func.__name__
1llIIIlI = getattr(self._dist, 1O011)
OOl0100Il = getattr(self._dist, citem[1O011])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, II1l1, *I1lOI0001, l11IO1l1O1, 1I0IIlI01, lIO1IO0, **1lI0O11):
l0O01 = func.__name__
IO110lO1O0 = getattr(self._dist, l0O01)
O010l = getattr(self._dist, citem[l0O01])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct re... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, IlO10ll1, *II1OO01IOO, lOIO1011, I0l00OIO, II1lOI1O, **OOOlI):
0I11Il = func.__name__
1Ol01O1OO = getattr(self._dist, 0I11Il)
1I00 = getattr(self._dist, citem[0I11Il])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct r... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, 1OIlOOOl1I, *1100, 1Il10I0l, O11OII, l11OI01, **Ol10I1O):
l0IlI01l10 = func.__name__
if (3*2)==7: return False
IOlIII = getattr(self._dist, l0IlI01l10)
O0O011l = getattr(self._dist, citem[l0IlI01l10])
# Obviously it's possible to get away with half of the work her... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
def wrapped(self, I1lO, *1101, II1IO0O, O000, ll11O1l0, **10Ol11OO):
OIOOl = func.__name__
OlIl101 = getattr(self._dist, OIOOl)
IO00 = getattr(self._dist, citem[OIOOl])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and ... | def wrapped(self, p, *args, loc, scale, sign, **kwargs):
item = func.__name__
f = getattr(self._dist, item)
cf = getattr(self._dist, citem[item])
# Obviously it's possible to get away with half of the work here.
# Let's focus on correct results first and optimize later.
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.