Path: csiph.com!usenet.pasdenom.info!nntpfeed.proxad.net!proxad.net!feeder1-2.proxad.net!news.tele.dk!news.tele.dk!small.news.tele.dk!newsgate.cistron.nl!newsgate.news.xs4all.nl!post.news.xs4all.nl!not-for-mail
MIME-Version: 1.0
In-Reply-To: <f2e51cb7-dbcf-4679-baf3-9b006b82e08c@googlegroups.com>
References: <f2e51cb7-dbcf-4679-baf3-9b006b82e08c@googlegroups.com>
From: Ian Kelly <ian.g.kelly@gmail.com>
Date: Fri, 17 Apr 2015 20:33:32 -0600
Subject: Re: Need opinions on P vs NP
To: Python <python-list@python.org>
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: quoted-printable
Precedence: list
Newsgroups: comp.lang.python
Message-ID: <mailman.389.1429324454.12925.python-list@python.org>
Lines: 58
NNTP-Posting-Host: 2001:888:2000:d::a6
Xref: csiph.com comp.lang.python:89105

On Fri, Apr 17, 2015 at 7:19 PM, Paddy <paddy3118@gmail.com> wrote:
> Having just seen Raymond's talk on Beyond PEP-8 here: https://www.youtube=
.com/watch?v=3Dwf-BqAjZb8M, it reminded me of my own recent post where I am=
 soliciting opinions from non-newbies on the relative Pythonicity of differ=
ent versions of a routine that has non-simple array manipulations.
>
> The blog post: http://paddy3118.blogspot.co.uk/2015/04/pythonic-matrix-ma=
nipulation.html
>
> The first, (and original), code sample:
>
> def cholesky(A):
>     L =3D [[0.0] * len(A) for _ in range(len(A))]
>     for i in range(len(A)):
>         for j in range(i+1):
>             s =3D sum(L[i][k] * L[j][k] for k in range(j))
>             L[i][j] =3D sqrt(A[i][i] - s) if (i =3D=3D j) else \
>                       (1.0 / L[j][j] * (A[i][j] - s))
>     return L
>
>
> The second equivalent code sample:
>
> def cholesky2(A):
>     L =3D [[0.0] * len(A) for _ in range(len(A))]
>     for i, (Ai, Li) in enumerate(zip(A, L)):
>         for j, Lj in enumerate(L[:i+1]):
>             s =3D sum(Li[k] * Lj[k] for k in range(j))
>             Li[j] =3D sqrt(Ai[i] - s) if (i =3D=3D j) else \
>                       (1.0 / Lj[j] * (Ai[j] - s))
>     return L
>
>
> The third:
>
> def cholesky3(A):
>     L =3D [[0.0] * len(A) for _ in range(len(A))]
>     for i, (Ai, Li) in enumerate(zip(A, L)):
>         for j, Lj in enumerate(L[:i]):
>             #s =3D fsum(Li[k] * Lj[k] for k in range(j))
>             s =3D fsum(Lik * Ljk for Lik, Ljk in zip(Li, Lj[:j]))
>             Li[j] =3D (1.0 / Lj[j] * (Ai[j] - s))
>         s =3D fsum(Lik * Lik for Lik in Li[:i])
>         Li[i] =3D sqrt(Ai[i] - s)
>     return L
>
> My blog post gives a little more explanation, but I have yet to receive a=
ny comments on relative Pythonicity.

I prefer the first version. You're dealing with mathematical formulas
involving matrices here, so subscripting seems appropriate, and
enumerating out rows and columns just feels weird to me.

That said, I also prefer how the third version pulls the last column
of each row out of the inner loop instead of using a verbose
conditional expression that you already know will be false for every
column except the last one. Do that in the first version, and I think
you've got it.