[Numpy-discussion] one-offset arrays
Travis Oliphant
oliphant.travis at ieee.org
Tue Aug 28 18:30:54 CDT 2001
> In my view, the most important reason to prefer 1-based indexing
> versus 0-based indexing is compatibility. For numerical work, some of
> the languages which I use or have used are Matlab, Mathematica, Maple
> and Fortran. These are all 1-indexed. (C is by nature 0-indexed
> because it is so close to machine architecture, but with a little bit
> of not-entirely-clean pointer manipulation, you can easily make
> 1-indexed arrays and matrices.) Obviously Python can't be compatible
> with these languages in a strict sense, but like most people who do
> some programming work, I've built up a library of my own commonly used
> routines specific to my work; in general it's a trivial matter to
> translate numerical routines from one language to the another if
> translation is just a matter of substituting of one set of syntactical
> symbols and function names for anther. However it can be damn tricky
> to convert 1-indexed code to 0-indexed code or visa versa without
> introducing any errors- believe me! (Yes it's possible to call nearly
> any language from nearly any other language these days so in theory
> you don't have to recode, but there are lots of reasons why often
> recoding is the preferable route.)
You aren't the first to raise this issue. I wouldn't mind if the user had
the option, but then I again I tend to prefer the flag-for-every-feature
approach which others who have more computing experience than me have said
leads to problems due to the presence of many different ways to do things and
unforseen interaction.s
I could definitely see the coding advantage in dealing with implementing
algorithms that uses notation that is already 1-based. I have come across
this myself -- in fact just yesterday when I was coding up the Pade
approximation to the matrix exponential using the pseudo-code algorithm given
by Golub and Van Loan in their "Matrix Computations" book.
It seems to me like it would be a lot of work to add this feature back into
the code now (there would be a million places to look for places where the
code inherently assumes 0-based indexing). It would also, as you mention, be
inconsistent with Python.
A general approach would be to inherit from the UserArray for your codes and
reimplement the __getitem__ and __getslice__ commands. Your objects should
still be able to be passed to many of the routines which expect arrays
(because under the covers one of the first things the array_from_object
C-code does is check to see if the object has an __array__ method and calls
it). Note that this will not copy data around so there is minimal overhead.
But, you would have to take care to wrap the returned object back into an
array_object. (Maybe something could be done here...Hmmm.)
>
> By the way, what is leave-last-one-out slicing? Is it
> a[:-1]
> or is it
> a[0,...]
> or is it something else?
I meant the fact that a[3:6] returns elements a[3], a[4], a[5] but NOT a[6].
I'm sorry for using my own poorly-worded term. I can't remember what other
Pythonistas call it.
More information about the Numpy-discussion
mailing list