Why not use list_name[-n%N] whenever you need to use negative indices and raise an index out of bounds exception with negative indices like other programming languages? ________________________________ From: Calvin Spealman Sent: Thursday, November 26, 2020 1:00 AM To: Mathew M. Noel Cc: python-ideas@python.org; mail@pradyunsg.me Subject: Re: [Python-ideas] Getting rid of FOR loops and simplifying cicular conviolutions with Circular Indexing days_of_the_week[14 % 7] There ya go! On Wed, Nov 25, 2020 at 12:51 PM Mathew M. Noel via Python-ideas mailto:python-ideas@python.org> wrote: If circular indexing is used then instead of using a double FOR loop to go through a list M times we can iterate from 0 to M*N (where N is the length of the list) !!! Almost all Machine Learning (ML) algorithms iterate for some predefined epochs over a large data-set. So a double FOR loop is extremely common in ML. Using circular indexing gets rid of this extra FOR loop. If we have to iterate 2 times you can iterate using range(-n,n) but in most cases you need to iterate over 10 or more epochs in ML. Most scientific applications of Python involve an outer FOR loop which progressively refines an approximation with an inner FOR loop by going through a list of items. So circular indexing is useful. In the following I discuss increasingly compelling reasons for adopting a circular indexing scheme in Python. Python uses an index of -1 to index the last element in a list. Since -1 occurs before 0 we might think of the elements of the linear list are being bent into a circle making the last element occur before the 0th element. Consider a list with n elements: it would be perfectly reasonable to address the element 0 of the list using an index of n since n occurs after n-1 (if we assume that the list is bent into a circle). This feature can prove to be extremely useful. Consider the following example: days_of_the_week = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"] It would be nice if days_of_the_week[0] is the same as days_of_the_week[7] is the same as days_of_the_week[14] etc In other words use modular indexing. In other words if the index is outside the range 0 to n-1, we simply take the remainder when the index is divided by n as the index. Because of the close relationship between finite length sequences and periodic sequences this feature might simplify scientific computing(circular convolution etc). If circular indexing is used then we don't need the arbitrary rule that -1 is the index of the last element. Since -1 is the same as n-1 automatically in modular arithmetic. A trivial objection: "why not use list_name[i%n] whenever we need this feature?" By the same token we could do away with negative indices and use -1%n for example when we need to index with -1! Its unclear why that people have an irrational preference for indices that lie to the left of 0 while strongly rejecting the idea of indices that lie to the right of n-1! Python does not raise a "index out of bound" exception for negative indices like other programming languages. If this negative indexing is a "feature" (although it allows some fatal errors to slip) then indices above n-1 can also be considered a feature! Are there any deep mathematical reasons for adopting circular convention? Circular convolution is a most important operation in a wide variety of scientific disciplines since the Discrete Fourier Transform (DFT) of the circular convolution of two signals is the product of the transforms. Because of the universal applicability of Fourier ideas in science and the close mathematical relationship between finite length and periodic sequences circular indexing is extensively used in signal processing and mathematics. We can extend the idea of circular indexing to multidimensional arrays. A 2D array can be folded into a cylinder for indexing. Further this cylinder can be folded into a toroid to reduce a triple FOR loop to a single FOR loop. A deep mathematical justification for cylindrical indexing of 2D and in general nD arrays is offered by the fact that n-dimensional DFT reduces n-dimensional circular convolution to element-wise multiplication. _______________________________________________ Python-ideas mailing list -- python-ideas@python.orgmailto:python-ideas@python.org To unsubscribe send an email to python-ideas-leave@python.orgmailto:python-ideas-leave@python.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://mail.python.org/archives/list/python-ideas@python.org/message/5TJYKF... Code of Conduct: http://python.org/psf/codeofconduct/ -- CALVIN SPEALMAN SENIOR QUALITY ENGINEER cspealma@redhat.commailto:cspealma@redhat.com M: +1.336.210.5107tel:+1.336.210.5107 [https://red.ht/sig]https://red.ht/sig TRIED. TESTED. TRUSTED.https://redhat.com/trusted

On Thu, Nov 26, 2020 at 04:56:34AM +0000, Mathew M. Noel via Python-ideas wrote:

Why not use list_name[-n%N] whenever you need to use negative indices and raise an index out of bounds exception with negative indices like other programming languages?

If this was Python 0.1 back in 1991, then that would be a good question. But it is 2020 and we have almost 30 years of negative indices counting from the end, and that's not going to change. -- Steve

Circular indexing will only extend the range of allowable indices to the set of all integers !!! Can you provide some example of the "billions of lines of working code" that the circular indexing scheme supposedly breaks so that we can have a more informed discussion? Deeper mathematical reason behind circular indexing is that it makes the use of negative indices logically consistent and simplifies implementation of the widely used convolution operation in signal processing. ________________________________ From: David Mertz Sent: Thursday, November 26, 2020 1:15 AM To: Mathew M. Noel Cc: python-ideas; mail@pradyunsg.me Subject: Re: [Python-ideas] Getting rid of FOR loops and simplifying cicular conviolutions with Circular Indexing You've started three separate threads to propose something that has exactly zero chance of happening, and would be of limited use in uncommon cases. And that would break literally billions of lines of working code. If you want the modulo operator, you are more than welcome to use it. If you want to subclass list, have at it. On Wed, Nov 25, 2020, 12:48 PM Mathew M. Noel via Python-ideas mailto:python-ideas@python.org> wrote: If circular indexing is used then instead of using a double FOR loop to go through a list M times we can iterate from 0 to M*N (where N is the length of the list) !!! Almost all Machine Learning (ML) algorithms iterate for some predefined epochs over a large data-set. So a double FOR loop is extremely common in ML. Using circular indexing gets rid of this extra FOR loop. If we have to iterate 2 times you can iterate using range(-n,n) but in most cases you need to iterate over 10 or more epochs in ML. Most scientific applications of Python involve an outer FOR loop which progressively refines an approximation with an inner FOR loop by going through a list of items. So circular indexing is useful. In the following I discuss increasingly compelling reasons for adopting a circular indexing scheme in Python. Python uses an index of -1 to index the last element in a list. Since -1 occurs before 0 we might think of the elements of the linear list are being bent into a circle making the last element occur before the 0th element. Consider a list with n elements: it would be perfectly reasonable to address the element 0 of the list using an index of n since n occurs after n-1 (if we assume that the list is bent into a circle). This feature can prove to be extremely useful. Consider the following example: days_of_the_week = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"] It would be nice if days_of_the_week[0] is the same as days_of_the_week[7] is the same as days_of_the_week[14] etc In other words use modular indexing. In other words if the index is outside the range 0 to n-1, we simply take the remainder when the index is divided by n as the index. Because of the close relationship between finite length sequences and periodic sequences this feature might simplify scientific computing(circular convolution etc). If circular indexing is used then we don't need the arbitrary rule that -1 is the index of the last element. Since -1 is the same as n-1 automatically in modular arithmetic. A trivial objection: "why not use list_name[i%n] whenever we need this feature?" By the same token we could do away with negative indices and use -1%n for example when we need to index with -1! Its unclear why that people have an irrational preference for indices that lie to the left of 0 while strongly rejecting the idea of indices that lie to the right of n-1! Python does not raise a "index out of bound" exception for negative indices like other programming languages. If this negative indexing is a "feature" (although it allows some fatal errors to slip) then indices above n-1 can also be considered a feature! Are there any deep mathematical reasons for adopting circular convention? Circular convolution is a most important operation in a wide variety of scientific disciplines since the Discrete Fourier Transform (DFT) of the circular convolution of two signals is the product of the transforms. Because of the universal applicability of Fourier ideas in science and the close mathematical relationship between finite length and periodic sequences circular indexing is extensively used in signal processing and mathematics. We can extend the idea of circular indexing to multidimensional arrays. A 2D array can be folded into a cylinder for indexing. Further this cylinder can be folded into a toroid to reduce a triple FOR loop to a single FOR loop. A deep mathematical justification for cylindrical indexing of 2D and in general nD arrays is offered by the fact that n-dimensional DFT reduces n-dimensional circular convolution to element-wise multiplication. _______________________________________________ Python-ideas mailing list -- python-ideas@python.orgmailto:python-ideas@python.org To unsubscribe send an email to python-ideas-leave@python.orgmailto:python-ideas-leave@python.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://mail.python.org/archives/list/python-ideas@python.org/message/5TJYKF... Code of Conduct: http://python.org/psf/codeofconduct/

On Thu, Nov 26, 2020 at 08:20:19AM +0000, Mathew M. Noel via Python-ideas wrote:

Circular indexing will only extend the range of allowable indices to the set of all integers !!!

Is that supposed to be a feature, or a terrible threat? [...]

Deeper mathematical reason behind circular indexing is that it makes the use of negative indices logically consistent

Negative indices are already logically consistent. Python's model for sequences is a *linear* sequence, not a circular sequence, and negative indices counting from the end is no less logical than positive indices counting from the start. Please stop wasting our time by claiming "logical consistency" as a unique benefit of your proposal. We already have logical consistency in a linear model, changing to a circular model doesn't add anything we don't already have.

and simplifies implementation of the widely used convolution operation in signal processing.

For the benefit of the 99.9% of Python programmers who have no idea what this "convolution operation" is, can you give an example? It's okay if it is a simplified example, even pseudo-code, so long as it is realistic. Please remember that the Python ecosystem supports programmers who are not just working in signal processing or machine learning, but system administrators, educators, students, hobbyists, web developers, business programming, natural language processing, graphics processing, and a host of other fields. For most of these fields, a circular model for sequences will be a step backwards, not forward. -- Steve

Every Python program that I have ever written implicitly relies on the current behavior of list.  Changing the builtin list type would be such a massive breaking change that it simply is not going to happen.  As others have noted, writing your own list subclass would solve your problem here. I would politely suggest that the burden of an informed discussion rests on you, as you are proposing the change. With circular indexing, how would I specifically select the 100th element of a list and nothing else?  I couldn't do just this anymore: my_list[99] With circular indexing, that could return any list item up to the 99th item, depending on the size of the list.  So in short, the list type would no longer work in the basic intuitive way that everyone I have ever encountered expects it to.  Instead, I would have to write each list access like this: if len(my_list) < 100: raise IndexError('list index out of range') else: my_list[99] No thanks.  Modifying the builtin list type for circular indexing is an "over my dead body" situation. --Edwin On 11/26/2020 3:20 AM, Mathew M. Noel via Python-ideas wrote:

Circular indexing will only extend the range of allowable indices to the set of

all integers !!!

Can you provide some example of the "billions of lines of working code" that the circular indexing scheme supposedly breaks so that we can have a more informed discussion?

Deeper mathematical reason behind circular indexing is that it makes the use of  negative indices logically consistent and simplifies implementation of the widely used convolution operation in signal processing.

------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ *From:* David Mertz *Sent:* Thursday, November 26, 2020 1:15 AM *To:* Mathew M. Noel *Cc:* python-ideas; mail@pradyunsg.me *Subject:* Re: [Python-ideas] Getting rid of FOR loops and simplifying cicular conviolutions with Circular Indexing   You've started three separate threads to propose something that has exactly zero chance of happening, and would be of limited use in uncommon cases. And that would break literally billions of lines of working code.

If you want the modulo operator, you are more than welcome to use it. If you want to subclass list, have at it.

On Wed, Nov 25, 2020, 12:48 PM Mathew M. Noel via Python-ideas mailto:python-ideas@python.org> wrote:

If circular indexing is used then instead of using a double FOR loop to go through a list M times we can iterate from 0 to M*N (where N is the length of the list) !!!

Almost all Machine Learning (ML) algorithms iterate for some predefined epochs over a large data-set. So a double FOR loop is extremely common in ML. Using circular indexing gets rid of this extra FOR loop. If we have to iterate 2 times you can iterate using range(-n,n) but in most cases you need to iterate over 10 or more epochs in ML.

Most scientific applications of Python involve an outer FOR loop which progressively refines an approximation with an inner FOR loop by going through a list of items. So circular indexing is useful. In the following I discuss increasingly compelling reasons for adopting a circular indexing scheme in Python.

Python uses an index of -1 to index the last element in a list. Since -1 occurs before 0 we might think of the elements of the linear list are being bent into a circle making the last element occur before the 0th element. Consider a list with n elements: it would be perfectly reasonable to address the element 0 of the list using an index of n since n occurs after n-1 (if we assume that the list is bent into a circle). This feature can prove to be extremely useful. Consider the following example:

days_of_the_week = ["Sunday","Monday","Tuesday","Wednesday","Thursday","Friday","Saturday"]

It would be nice if

days_of_the_week[0]

is the same as

days_of_the_week[7]

is the same as

days_of_the_week[14] etc

In other words use modular indexing. In other words if the index is outside the range 0 to n-1, we simply take the remainder when the index is divided by n as the index. Because of the close relationship between finite length sequences and periodic sequences this feature might simplify scientific computing(circular convolution etc).

If circular indexing is used then we don't need the arbitrary rule that -1 is the index of the last element. Since -1 is the same as n-1 automatically in modular arithmetic.

A trivial objection:  "why not use list_name[i%n] whenever we need this feature?" By the same token we could do away with negative indices and use -1%n for example when we need to index with -1!

Its unclear why that people have an irrational preference for indices that lie to the left of 0 while strongly rejecting the idea of indices that lie to the right of n-1!

Python does not raise a "index out of bound" exception for negative indices like other programming languages. If this negative indexing is a "feature" (although it allows some fatal errors to slip) then indices above n-1 can also be considered a feature!

Are there any deep mathematical reasons for adopting  circular convention? Circular convolution is a most important operation in a wide variety of scientific disciplines since the Discrete Fourier Transform (DFT) of the circular convolution of two signals is the product of the transforms. Because of the universal applicability of Fourier ideas in science and the close mathematical relationship between finite length and periodic sequences circular indexing is extensively used in signal processing and mathematics.

We can extend the idea of circular indexing to multidimensional arrays. A 2D array can be folded into a cylinder for indexing. Further this cylinder can be folded into a toroid to reduce a triple FOR loop to a single FOR loop. A deep mathematical justification for cylindrical indexing of 2D and in general nD arrays is offered by the fact that n-dimensional DFT reduces n-dimensional circular convolution to element-wise multiplication.

_______________________________________________ Python-ideas mailing list -- python-ideas@python.org mailto:python-ideas@python.org To unsubscribe send an email to python-ideas-leave@python.org mailto:python-ideas-leave@python.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://mail.python.org/archives/list/python-ideas@python.org/message/5TJYKF... Code of Conduct: http://python.org/psf/codeofconduct/ http://python.org/psf/codeofconduct/

_______________________________________________ Python-ideas mailing list -- python-ideas@python.org To unsubscribe send an email to python-ideas-leave@python.org https://mail.python.org/mailman3/lists/python-ideas.python.org/ Message archived at https://mail.python.org/archives/list/python-ideas@python.org/message/3KTOJD... Code of Conduct: http://python.org/psf/codeofconduct/