OK. That explains a bit more.

 

If I understand what you are looking for is a fast implementation and quite 
often in Pyhon it means using code written in another language such as C that 
is integrated carefully in a moule or two. Another tack is to replace many 
explicit loops with often much faster vectorized operations. Numpy provides 
advantages like the above if you use it as intended.

 

Of course there are other techniques in how code is refactored or the order of 
operations, or doing things in parallel.

 

Just as an example, your inner loop ear the top is operating one at a time or 
numbers between 0 and max_l and hen creates variables initialized and then 
possibly changed in chvec and maxmult. It uses various conditions to change 
those variables then goes on to do more things included in a fourth nested loop.

 

What would happen if, instead, you used two objects with the same names that 
were each a numpy array, or perhaps combined into a dataframe type object?

 

Using numpy (and perhaps pandas) you could have code that initialized one such 
array to hold the initial 1 or 2 as needed in an object whose length was 
max_l+1 and then the next operations, using numpy notation would be along the 
lines of replace the corresponding value depending on external variables you 
call h or k and so on. 

 

There would be several invisible loops, perhaps chained in some way, but 
probably running way faster than the explicit loop.

 

I am not going to write any specific code, but suggest you read some 
documentation on how to use numpy for some of the operations you want when 
operating on larger clusters of info. You can gain some speed even by changing 
a few parts. To refactor the entire thing would take more thought and if you 
come up with the idea  of operating on a multidimensional array, might take 
some care. 

 

But consider what would happen if you looked at your loops which are currently 
of a fixed size and created  a 3-D matrix with dimensions of max_h+1, max_k+1, 
and max_l+1 and simply initialized it with all possible initial values and then 
ran an algorithm to manipulate it, often asking numpy for various slices or 
whatever works for you as in axes.  This architecture may not work for ou but 
is an example of the kind of thinking it an take to make a problem use 
algorithms more efficiently.

 

I note the code did not actually help me understand what mathematical operation 
you want to perform. I assumed I might see some operations like division and t 
may be other parts of your code that implement what you want.

 

But if this is a common enough need, I suspect you may want to see if something 
similar enough is out there. Your code may be more complex and more like the 
sieve of Eratosthenes that attempts to test every possibility.

 

One algorithm I have seen simply takes the numbers you are evaluating and in a 
loop of the first N primes (or an open-ended generator) simply does an integer 
division by 2, as many times as it returns an integral result, then as many 
divisions by 3 then 5 and 7 and so on.  It aborts when it has been chopped down 
to size, or the prime being used is large enough (square root or so) ad at the 
end, you should have some sequence of divisors, or just  and the number if it 
is prime. Some such algorithm can be fairly fast and perhaps can even be done 
vectorized. 

 

One last comment is about memoization. If your data is of a nature where a 
relatively few numbers come up often, then you an use something, like perhaps a 
dictionary, to store the results of a computation like getting a list of prime 
factors for a specific number, or just recording whether it is prime or 
composite. Later calls to do calculations would always check if the result has 
already been saved and skip recalculating it.

 

Good Luck

 

 

From: Popov, Dmitry Yu <dpo...@anl.gov> 
Sent: Thursday, July 11, 2024 3:26 PM
To: avi.e.gr...@gmail.com; 'Popov, Dmitry Yu via Python-list' 
<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 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

 

 

  _____  

From: avi.e.gr...@gmail.com <mailto:avi.e.gr...@gmail.com>  
<avi.e.gr...@gmail.com <mailto:avi.e.gr...@gmail.com> >
Sent: Thursday, July 11, 2024 1:22 PM
To: Popov, Dmitry Yu <dpo...@anl.gov <mailto:dpo...@anl.gov> >; 'Popov, Dmitry 
Yu via Python-list' <python-list@python.org <mailto:python-list@python.org> >
Subject: RE: Relatively prime integers in NumPy 

 

Дмитрий, You may think you explained what you wanted but I do not see what 
result you expect from your examples. Your request is a bit too esoteric to be 
a great candidate for being built into a module like numpy for general purpose 
se but 

ZjQcmQRYFpfptBannerStart

This Message Is From an External Sender 

This message came from outside your organization. 

 

ZjQcmQRYFpfptBannerEnd

Дмитрий,
 
You may think you explained what you wanted but I do not see what result you
expect from your examples.
 
Your request is a bit too esoteric to be a great candidate for being built
into a module like numpy for general purpose se but I can imagine it could
be available in modules build on top of numpy.
 
Is there a reason you cannot solve this mostly outside numpy?
 
It looks like you could use numpy to select the numbers you want to compare,
then call one of many methods you can easily search for to see  how to use
python to make some list or other data structure for divisors of each number
involved and then use standard methods to compare the lists and exact common
divisors. If needed, you could then put the results back into your original
data structure using numpy albeit the number of matches can vary.
 
Maybe a better explanation is needed as I cannot see what your latter words
about -1 and 1 are about. Perhaps someone else knows.
 
 
 
 
-----Original Message-----
From: Python-list <python-list-bounces+avi.e.gross=gmail....@python.org 
<mailto:python-list-bounces+avi.e.gross=gmail....@python.org> > On
Behalf Of Popov, Dmitry Yu via Python-list
Sent: Monday, July 8, 2024 3:10 PM
To: Popov, Dmitry Yu via Python-list <python-list@python.org 
<mailto:python-list@python.org> >
Subject: Relatively prime integers in NumPy
 
Dear Sirs.
 
Does NumPy provide a simple mechanism to identify relatively prime integers,
i.e. integers which don't have a common factor other than +1 or -1? For
example, in case of this array:
[[1,5,8],
  [2,4,8],
  [3,3,9]]
I can imagine a function which would return array of common factors along
axis 0: [1,2,3]. Those triples of numbers along axis 1 with the factor of1
or -1 would be relatively prime integers.
 
Regards,
Dmitry Popov
 
Argonne, IL
USA
 
-- 
https://urldefense.us/v3/__https://mail.python.org/mailman/listinfo/python-list__;!!G_uCfscf7eWS!ZGK1ZXYgmC6cpNa1xTXVTNklhunjYiinwaDe_xE3sJyVs4ZcVgUB_v2FKvDzDspx7IzFCZI7JpFsiV5iH58P$
 
<https://urldefense.us/v3/__https:/mail.python.org/mailman/listinfo/python-list__;!!G_uCfscf7eWS!ZGK1ZXYgmC6cpNa1xTXVTNklhunjYiinwaDe_xE3sJyVs4ZcVgUB_v2FKvDzDspx7IzFCZI7JpFsiV5iH58P$>
 
 
-- 
https://mail.python.org/mailman/listinfo/python-list

Reply via email to