Dmitry,

Efficiency of several kinds is hotly debated and sometimes it depends a lot on what is done within loops.

Many suggest a mild speed up of some comprehensions over loops but the loops are not gone but somewhat hidden and perhaps some aspects are faster for having been written in C carefully and not interpreted.

Comprehensions (and there are other versions that generate dictionaries and tuples and sets) may also be sped up a bit for other reasons like your fairly expensive APPPEND that has to keep finding the end o f a growing list and is not done the same way in a comprehension.

If you do a search, you find many opinions including on using functional programming techniques such as map/reduce. There are also

Your particular case is interesting because it just makes all combination of three variables. Some languages, like R, have functions that do this for you, like expand.grd. Python has many modules, like itertools that do things including combinations but perhaps not designed for your case.

Here is a version of your scenario:

import itertools

a = range(3)

b = range(4)

c = range(5)

list(itertools.product(a,b,c))

The result comes as tuples but as you are moving the result into numpy, does it matter:

>>> list(itertools.product(a,b,c))

[(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 0, 4), (0, 1, 0), (0, 1, 1), (0, 1, 2), (0, 1, 3), (0, 1, 4), (0, 2, 0), (0, 2, 1), (0, 2, 2), (0, 2, 3), (0, 2, 4), (0, 3, 0), (0, 3, 1), (0, 3, 2), (0, 3, 3), (0, 3, 4), (1, 0, 0), (1, 0, 1), (1, 0, 2), (1, 0, 3), (1, 0, 4), (1, 1, 0), (1, 1, 1), (1, 1, 2), (1, 1, 3), (1, 1, 4), (1, 2, 0), (1, 2, 1), (1, 2, 2), (1, 2, 3), (1, 2, 4), (1, 3, 0), (1, 3, 1), (1, 3, 2), (1, 3, 3), (1, 3, 4), (2, 0, 0), (2, 0, 1), (2, 0, 2), (2, 0, 3), (2, 0, 4), (2, 1, 0), (2, 1, 1), (2, 1, 2), (2, 1, 3), (2, 1, 4), (2, 2, 0), (2, 2, 1), (2, 2, 2), (2, 2, 3), (2, 2, 4), (2, 3, 0), (2, 3, 1), (2, 3, 2), (2, 3, 3), (2, 3, 4)]

Or a atd easier to read pretty printed:

>>> import pprint

>>> pprint.pprint(list(itertools.product(a,b,c)))

[(0, 0, 0),

(0, 0, 1),

(0, 0, 2),

(0, 0, 3),

(0, 0, 4),

(0, 1, 0),

(0, 1, 1),

(0, 1, 2),

(0, 1, 3),

(0, 1, 4),

(0, 2, 0),

(0, 2, 1),

(0, 2, 2),

(0, 2, 3),

(0, 2, 4),

(0, 3, 0),

(0, 3, 1),

(0, 3, 2),

(0, 3, 3),

(0, 3, 4),

(1, 0, 0),

(1, 0, 1),

(1, 0, 2),

(1, 0, 3),

(1, 0, 4),

(1, 1, 0),

(1, 1, 1),

(1, 1, 2),

(1, 1, 3),

(1, 1, 4),

(1, 2, 0),

(1, 2, 1),

(1, 2, 2),

(1, 2, 3),

(1, 2, 4),

(1, 3, 0),

(1, 3, 1),

(1, 3, 2),

(1, 3, 3),

(1, 3, 4),

(2, 0, 0),

(2, 0, 1),

(2, 0, 2),

(2, 0, 3),

(2, 0, 4),

(2, 1, 0),

(2, 1, 1),

(2, 1, 2),

(2, 1, 3),

(2, 1, 4),

(2, 2, 0),

(2, 2, 1),

(2, 2, 2),

(2, 2, 3),

(2, 2, 4),

(2, 3, 0),

(2, 3, 1),

(2, 3, 2),

(2, 3, 3),

(2, 3, 4)]

I think that is close enough to what you want but is it faster? You can try a benchmarking method on alternatives.

From: Popov, Dmitry Yu <dpopov@anl.gov>
Sent: Friday, July 12, 2024 11:10 PM
To: avi.e.gross@gmail.com; 'Popov, Dmitry Yu via Python-list' <python-list@python.org>; oscar.j.benjamin@gmail.com
Subject: Re: Relatively prime integers in NumPy

Thank you very much. List comprehensions make code much more concise indeed. Do list comprehensions also improve the speed of calculations?

_____

From: avi.e.gross@gmail.com <mailto:avi.e.gross@gmail.com> <avi.e.gross@gmail.com <mailto:avi.e.gross@gmail.com> >
Sent: Friday, July 12, 2024 6:57 PM
To: Popov, Dmitry Yu <dpopov@anl.gov <mailto:dpopov@anl.gov> >; 'Popov, Dmitry Yu via Python-list' <python-list@python.org <mailto:python-list@python.org> >; oscar.j.benjamin@gmail.com <mailto:oscar.j.benjamin@gmail.com> <oscar.j.benjamin@gmail.com <mailto:oscar.j.benjamin@gmail.com> >
Subject: RE: Relatively prime integers in NumPy

Dmitry, I clearly did not understand what you wanted earlier as you had not made clear that in your example, you already had progressed to some level where you had the data and were now doing a second step. So, I hesitate to say much until

ZjQcmQRYFpfptBannerStart

This Message Is From an External Sender

This message came from outside your organization.

ZjQcmQRYFpfptBannerEnd

Dmitry,

I clearly did not understand what you wanted earlier as you had not made clear that in your example, you already had progressed to some level where you had the data and were now doing a second step. So, I hesitate to say much until either nobody else addressed the issue (as clearly some have) or you explain well enough.

Ditr

I am guessing you have programming experience in other languages and are not as “pythonic” as some. The code you show may not be quite how others might do it. Some may write mch of your code as a single line of python using a list comprehension such as:

hkl_list = [ [h, k, l] for SOMETHING in RANGE for SOMETHING2 in RANGE2 for SOMETHING3 in RANGE3]

Where h, k. l come from the somethings.

Back to the real world.

From: Popov, Dmitry Yu <dpopov@anl.gov <mailto:dpopov@anl.gov> >
Sent: Friday, July 12, 2024 1:13 PM
To: avi.e.gross@gmail.com <mailto:avi.e.gross@gmail.com> ; 'Popov, Dmitry Yu via Python-list' <python-list@python.org <mailto:python-list@python.org> >; oscar.j.benjamin@gmail.com <mailto:oscar.j.benjamin@gmail.com> ; Popov, Dmitry Yu <dpopov@anl.gov <mailto:dpopov@anl.gov> >
Subject: Re: Relatively prime integers in NumPy

Thank you very much, Oscar.

Using the following code looks like a much better solution than my current Python code indeed.

np.gcd.reduce(np.transpose(a))
or
np.gcd.reduce(a,1)
The next question is how I can generate ndarray of h,k,l indices. This can be easily done from a Python list by using the following code.
import numpy as np
hkl_list=[]
for h in range(0, max_h):
      for k in range(0, max_k):
            for l in range(0, max_l):
                  hkl_local=[]
                  hkl_local.append(h)
                  hkl_local.append(k)
                  hkl_local.append(l)
                  hkl_list.append(hkl_local)
hkl=np.array(hkl_list, dtype=np.int64)
This code will generate a two-dimensional ndarray of h,k,l indices but is it possible to make a faster routine with NumPy?
Regards,
Dmitry

_____

From: Python-list <python-list-bounces+dpopov=anl.gov@python.org <mailto:python-list-bounces+dpopov=anl.gov@python.org> > on behalf of Popov, Dmitry Yu via Python-list <python-list@python.org <mailto:python-list@python.org> >
Sent: Thursday, July 11, 2024 2:25 PM
To: avi.e.gross@gmail.com <mailto:avi.e.gross@gmail.com> <avi.e.gross@gmail.com <mailto:avi.e.gross@gmail.com> >; 'Popov, Dmitry Yu via Python-list' <python-list@python.org <mailto:python-list@python.org> >
Subject: Re: Relatively prime integers in NumPy

Thank you for your interest. My explanation is too concise indeed, sorry. So far, I have used Python code with three enclosed 'for' loops for this purpose which is pretty time consuming. I'm trying to develop a NumPy based code to make this

ZjQcmQRYFpfptBannerStart

This Message Is From an External Sender

This message came from outside your organization.

ZjQcmQRYFpfptBannerEnd

Thank you for your interest. My explanation is too concise indeed, sorry. So far, I have used Python code with three enclosed 'for' loops for this purpose which is pretty time consuming. I'm trying to develop a NumPy based code to make this procedure faster. This routine is kind of 'heart' of the algorithm to index of X-ray Laue diffraction patterns. In our group we have to process huge amount of such patterns. They are collected at a synchrotron radiation facility. Faster indexation routine would help a lot.
This is the code I'm currently using. Any prompts how to implement it in NumPy would be highly appreciated.
for h in range(0, max_h):
      for k in range(0, max_k):
            for l in range(0, max_l):
                  chvec=1
                  maxmult=2
                  if h > 1:                     
                        maxmult=h
                  if k > 1:
                        maxmult=k
                  if l > 1:
                        maxmult=l
                  if h > 1:
                        if maxmult > h:
                              maxmult=h
                  if k > 1:
                        if maxmult > k:
                              maxmult=k
                  if l > 1:
                        if maxmult > l:
                              maxmult=l
                  maxmult=maxmult+1
                  for innen in range(2, maxmult):
                        if h in range(0, (max_h+1), innen):
                              if k in range(0, (max_k+1), innen):
                                    if l in range(0, (max_l+1), innen):
                                          chvec=0
                  if chvec==1:
                        # Only relatively prime integers h,k,l pass to this block of the code

Click here to read the complete article