Please ignore this bit of my previous message:
> >>> abs(-1)
> ObjectArray(1)
Something in my environment (probably me) got a bit confused.
Gary
--
___________________________________________________________
Sign-up for Ads Free at Mail.comhttp://promo.mail.com/adsfreejump.htm

I found a couple more incompatibilities between Numeric and numarray object array handling.
When I print an object array in Numeric, if the __str__ method exists for the contained object type, Numeric uses it to print the object.
However, numarray uses the __repr__ method instead.
This breaks my doctest strings
I think Numeric does it correctly.
In my example I have a class called Err with
def __repr__(self):
return "Err(%s,%s,%s)" % (self.value, self.posErr, self.negErr)
def __str__(self):
return "%s +%s/-%s" % (self.value, self.posErr, self.negErr)
Numeric behaves as follows (Note: ArrayOfErr() is just building an object array):
>>> print ArrayOfErr([909., 802., 677., 585.], 1.0)
[909.0 +1.0/-1.0 802.0 +1.0/-1.0 677.0 +1.0/-1.0 585.0 +1.0/-1.0 ]
whereas numarray does this:
>>> print ArrayOfErr([909., 802., 677., 585.], 1.0)
[Err(909.0,1.0,1.0), Err(802.0,1.0,1.0), Err(677.0,1.0,1.0),
Err(585.0,1.0,1.0)]
It also appears that if you try to apply the funtion abs to a built-in Python number type
after doing a 'from numarray import *',
instead of using Python's abs() function as Numeric does and returning a number, numarray
creates an ObjectArray containing the number and returns it. This may be a bug. Note also
the different answer when an int or float type is passed as an argument to cos:
>>> from Numeric import *
>>> cos(1)
0.54030230586813977
>>> cos(1.)
0.54030230586813977
>>> abs(-1)
1
>>> from numarray import *
>>> cos(1)
0.54030227661132813
>>> cos(1.)
0.54030230586813977
>>> abs(-1)
ObjectArray(1)
--
___________________________________________________________
Sign-up for Ads Free at Mail.comhttp://promo.mail.com/adsfreejump.htm

Hello folks,
On some numarray code I have, I get the error:
** On entry to DGESDD parameter number 12 had an illegal value
when calling singular_value_decomposition on a slightly large array (2D
matrix), but not on smaller arrays. Is there perhaps something that I am
doing wrong, or is this a bug in numarray? (I suppose that either way,
this is a bug, as an error on my part should give a python error rather
than a LAPACK error.)
[Incidentally, parameter 12 seems to be the lwork parameter, as far as I
can tell. I don't immediately see what value it could have that would be
illegal, but then, I don't know anything about LAPACK really, and the C
code for it is not easy to read.]
More info available on request, of course, as well as the code that is
causing the problems.
Thanks.
-Jon Bober

I thought I'd better try porting my Numeric python module to numarray before posting it to somewhere like Activestate's Python Cookbook site. By the way, if you have a suggestion about a more appropriate place to post what is a potentially useful generic module based on Numpy, can you let me know. It would be nice to have some sort of repository for useful modules.
In my module based on Numeric, I build an array of PyObjects:
def ArrayOfErr(errList, posErr=0., negErr=None):
valArray = array([], 'O')
for e in errList:
if type(e) == types.TupleType:
newErrObject = apply(Err, tuple(e))
elif type(e) == types.FloatType or types.IntType:
newErrObject = Err(e, posErr, negErr)
valArray = concatenate((valArray, array([newErrObject], 'O')))
return valArray
numarray.objects can't handle the first line.
Likewise
a = fromlist([])
fails.
Numeric doesn't seem to have a way of building a PyObject array dynamically,
so doing it the way I've shown seemed necessary to me.
Porting to numarray required building the list first as follows:
def ArrayOfErr(errList, posErr=0., negErr=None):
valArray = []
for e in errList:
if type(e) == types.TupleType:
newErrObject = apply(Err, tuple(e))
elif type(e) == types.FloatType or types.IntType:
newErrObject = Err(e, posErr, negErr)
valArray.append(newErrObject)
return fromlist(valArray)
You might like to think about supporting zero length object arrays to maintain compatibility.
By the way, I'm using object arrays to hold a Python number type which can by coerced to from a standard Python number type. I can therefore do things like add an array of my objects to a Numpy array of floats for example and the members of the standard Numpy array elements are coerced elementwise to my type producing a new Numpy object array. I wasn't sure that Numeric/numarray would handle this properly, since the documentation implies object arrays are only useful for manipulating arrays without casting types, but it does it correctly - lovely!
Gary Ruben
--
___________________________________________________________
Sign-up for Ads Free at Mail.comhttp://promo.mail.com/adsfreejump.htm

First public release. Comments sought.
dsptools
========
Here be Python wrappers for portaudio, ladspa and libsndfile.
There are three modules: ladspa, sndfile, and portaudio.
They are independant of each other, ie. they should compile/run individualy.
Data interchange is type sensitive and uses numarray arrays to store sound data.
It's possible to segfault by doing stupid things, eg. from within the portaudio callback only some portaudio calls are allowed.
See the python scripts for example usage, *.pyx files for implementation, and *.pxi for underlying c library info.
http://sourceforge.net/projects/dsptools/
It's under tested, under documented, but it's pretty cool.
Install
-------
Use any of the setup scripts:
$ python setup*.py build
$ python setup*.py install
Dependancies
------------
python 2.2.3 or better:
http://www.python.org/
numarray 0.8.1 (or better):
http://sourceforge.net/projects/numpy/
For portaudio module:
portaudio v18.1 (not v19):
http://www.portaudio.com/
For sndfile module:
libsndfile 1.0.5 or better:
http://www.mega-nerd.com/libsndfile/
For ladspa module:
ladspa.h v1.1 :
http://www.ladspa.org/ladspa_sdk/
and any plugins (optional):
http://www.ladspa.org/
Todo
----
* Enable the writing of ladspa plugins in python (!)
* portaudio v19
Related Projects
----------------
fastaudio, for portaudio & libsndfile :
http://www.freenet.org.nz/python/pyPortAudio/
libsndfile-python :
http://arcsin.org/archive/20030520025359.shtml
Thanks to
---------
Ross Bencina (portaudio)
Erik de Castro Lopo (libsndfile)
Greg Ewing and all the pyrex people
------------------------------------------------------------
Simon Burton
March 23, 2004
--
Simon Burton, B.Sc.
Licensed PO Box 8066
ANU Canberra 2601
Australia
Ph. 61 02 6249 6940
http://arrowtheory.com

The nd_image module in numarray has a spline intrpolation function
(spline_filter1d). I've tried it, and it is OK.
Nadav.
-----Original Message-----
From: Ray Schumacher [mailto:rays@blue-cove.com]
Sent: Tue 23-Mar-04 03:11
To: numpy-discussion(a)lists.sourceforge.net
Cc:
Subject: [Numpy-discussion] interpolating arrays (?)
Howdy,
I'd like to resize an array (1-dimensional) a of length n into an array of
n+x, and interpolate the values as necessary.
x might be+/-200, len(a) is usually ~500
I tried it in pure Python but it's not quite right yet. (rubberBand, below)
Someone out there must have done this... and linear interpolation for
values is probably sufficient (instead of bi-cubic or some such)
Cheers,
Ray
==================================================================
startSlice = 10000
endOfSlice =
10000+int(round(self.samplesPerRotation)) #self.samplesPerRotation=661
## self.dataArray is about len=200,000 of Int
for delta in range(-2,3):
## interpolate the different slices to the original length
## 0 should return the same array, this is a test
newArray = self.rubberBand(
self.dataArray[startSlice:endOfSlice+delta],
round(self.samplesPerRotation))
print len(self.dataArray[startSlice:endOfSlice+delta]),
len(newArray),
## show the result
print delta, Numeric.sum(self.dataArray[startSlice:endOfSlice]
- newArray)
def rubberBand(self, data, desiredLength):
""" alias/interpolate the data so that it is adjusted to the
desired array length"""
currentLength = float(len(data))
## positive if the new array is to be longer
difference = desiredLength - currentLength
#print difference, desiredLength, currentLength
## set up the desired length array
newData = Numeric.zeros(desiredLength, Numeric.Float)
## accounts for binary rounding errors
smallNum = 2**-14
for index in range(desiredLength):
## find the ratio of the current index to the desired length
ratio = index / float(desiredLength)
## find the same (float) position in the old data
currIndex = int(ratio * currentLength)
## find the decimal part
decimalPart = (ratio * currentLength) - currIndex
print index, currIndex, decimalPart,
if(decimalPart>smallNum):
## interpolate
newData[index] = ((1 - decimalPart) * data[currIndex] +
decimalPart * data[currIndex+1])
print data[currIndex], data[currIndex+1], newData[index]
else:
newData[index] = data[currIndex]
print 'else',data[currIndex], newData[index]
return newData
-------------------------------------------------------
This SF.Net email is sponsored by: IBM Linux Tutorials
Free Linux tutorial presented by Daniel Robbins, President and CEO of
GenToo technologies. Learn everything from fundamentals to system
administration.http://ads.osdn.com/?ad_id=1470&alloc_id=3638&op=click
_______________________________________________
Numpy-discussion mailing list
Numpy-discussion(a)lists.sourceforge.net
https://lists.sourceforge.net/lists/listinfo/numpy-discussion

Hi Tim,
I implemented the below code with good results; and if I go to a C version
in the future I'll let you know. As the raw data is integer and a bit
coarse at times, it will also help to have a non-linear method. I use a
parabolic interpolation for finding centriods of clipped stellar images,
but that's still Python too.
>With that one comes up with (untested):
>
>def rubberBand(self, y, desiredLength):
> # Define raw so that raw[0] == 0 and raw[-1] == len(y)-1 and
> len(raw) == desiredLength
> raw =arange(desiredLength) * (len(y) - 1) / (float(desiredLength) - 1)
> jVals = na.clip(na.floor(raw), 0, len(y)-2).astype('i')
> delta = raw - jVals
> dy = y[1:] - y[:-1]
> return na.take(y, jVals) + delta * na.take(dy, jVals)
>
>Hope that's helpful,
quite.
>PS, I just realized, these snippets assume a 'import numarray as na'
>somewhere above. Numeric should also work if the names are adjusted
>appropriately.
It does. I use Numeric for when arrays are length< 2000, as someone posted
some results to that effect a while back. numarray is certainly faster for
images.
In general, I'm using FFT for ballpark estimation of periodicity, then
doing time domain data comparison for more precise alignment.
Thanks to Chris, Konrad and Warren as well,
Ray

At 08:19 PM 3/22/04 -0800, Warren Focke wrote:
>Would you consider Fourier interpolation?
I'll try it out tomorrow and check the results.
Thanks!
Ray
>interpolated = FFT.inverse_real_fft(FFT.real_fft(data), desiredLength) * \
> desiredLength / len(data)
>
>This works whether desiredLength is less or greater than len(data). The
>trick here is that inverse_real_fft discards data or zero-pads at high
>frequencies. I keep toying with the idea of modifying the complex
>version to do the same, I cannot imagine a use for the current behavior
>(truncate or pad at small negative frequencies).
>
>There can be some pretty wierd edge effects, they can often be defeated
>with padding, or, better yet, overlapping segments. Geting that right
>might be harder than fixing your approach.
>
>It has the nice feature that it is information-preserving: if you
>interpolate to a higher number of points, then back to the original, you
>should get the same numbers back, give or take a little bit of rounding
>error.
>
>Warren Focke
>
>On Mon, 22 Mar 2004, Ray Schumacher wrote:
>
> > Howdy,
> >
> > I'd like to resize an array (1-dimensional) a of length n into an array of
> > n+x, and interpolate the values as necessary.
> > x might be+/-200, len(a) is usually ~500
> >
> > I tried it in pure Python but it's not quite right yet. (rubberBand, below)
> > Someone out there must have done this... and linear interpolation for
> > values is probably sufficient (instead of bi-cubic or some such)
> >
> > Cheers,
> > Ray
> >
> >
> >
> >
> > ==================================================================
> > startSlice = 10000
> > endOfSlice =
> > 10000+int(round(self.samplesPerRotation)) #self.samplesPerRotation=661
> > ## self.dataArray is about len=200,000 of Int
> >
> > for delta in range(-2,3):
> > ## interpolate the different slices to the original length
> > ## 0 should return the same array, this is a test
> > newArray = self.rubberBand(
> >
> self.dataArray[startSlice:endOfSlice+delta],
> > round(self.samplesPerRotation))
> > print len(self.dataArray[startSlice:endOfSlice+delta]),
> > len(newArray),
> > ## show the result
> > print delta, Numeric.sum(self.dataArray[startSlice:endOfSlice]
> > - newArray)
> >
> > def rubberBand(self, data, desiredLength):
> > """ alias/interpolate the data so that it is adjusted to the
> > desired array length"""
> > currentLength = float(len(data))
> >
> > ## positive if the new array is to be longer
> > difference = desiredLength - currentLength
> > #print difference, desiredLength, currentLength
> >
> > ## set up the desired length array
> > newData = Numeric.zeros(desiredLength, Numeric.Float)
> >
> > ## accounts for binary rounding errors
> > smallNum = 2**-14
> >
> > for index in range(desiredLength):
> > ## find the ratio of the current index to the desired length
> > ratio = index / float(desiredLength)
> >
> > ## find the same (float) position in the old data
> > currIndex = int(ratio * currentLength)
> > ## find the decimal part
> > decimalPart = (ratio * currentLength) - currIndex
> > print index, currIndex, decimalPart,
> > if(decimalPart>smallNum):
> > ## interpolate
> > newData[index] = ((1 - decimalPart) * data[currIndex] +
> > decimalPart * data[currIndex+1])
> > print data[currIndex], data[currIndex+1], newData[index]
> > else:
> > newData[index] = data[currIndex]
> > print 'else',data[currIndex], newData[index]
> >
> > return newData
> >
> >
> >
> > -------------------------------------------------------
> > This SF.Net email is sponsored by: IBM Linux Tutorials
> > Free Linux tutorial presented by Daniel Robbins, President and CEO of
> > GenToo technologies. Learn everything from fundamentals to system
> > administration.http://ads.osdn.com/?ad_id=1470&alloc_id=3638&op=click
> > _______________________________________________
> > Numpy-discussion mailing list
> > Numpy-discussion(a)lists.sourceforge.net
> > https://lists.sourceforge.net/lists/listinfo/numpy-discussion
> >

Howdy,
I'd like to resize an array (1-dimensional) a of length n into an array of
n+x, and interpolate the values as necessary.
x might be+/-200, len(a) is usually ~500
I tried it in pure Python but it's not quite right yet. (rubberBand, below)
Someone out there must have done this... and linear interpolation for
values is probably sufficient (instead of bi-cubic or some such)
Cheers,
Ray
==================================================================
startSlice = 10000
endOfSlice =
10000+int(round(self.samplesPerRotation)) #self.samplesPerRotation=661
## self.dataArray is about len=200,000 of Int
for delta in range(-2,3):
## interpolate the different slices to the original length
## 0 should return the same array, this is a test
newArray = self.rubberBand(
self.dataArray[startSlice:endOfSlice+delta],
round(self.samplesPerRotation))
print len(self.dataArray[startSlice:endOfSlice+delta]),
len(newArray),
## show the result
print delta, Numeric.sum(self.dataArray[startSlice:endOfSlice]
- newArray)
def rubberBand(self, data, desiredLength):
""" alias/interpolate the data so that it is adjusted to the
desired array length"""
currentLength = float(len(data))
## positive if the new array is to be longer
difference = desiredLength - currentLength
#print difference, desiredLength, currentLength
## set up the desired length array
newData = Numeric.zeros(desiredLength, Numeric.Float)
## accounts for binary rounding errors
smallNum = 2**-14
for index in range(desiredLength):
## find the ratio of the current index to the desired length
ratio = index / float(desiredLength)
## find the same (float) position in the old data
currIndex = int(ratio * currentLength)
## find the decimal part
decimalPart = (ratio * currentLength) - currIndex
print index, currIndex, decimalPart,
if(decimalPart>smallNum):
## interpolate
newData[index] = ((1 - decimalPart) * data[currIndex] +
decimalPart * data[currIndex+1])
print data[currIndex], data[currIndex+1], newData[index]
else:
newData[index] = data[currIndex]
print 'else',data[currIndex], newData[index]
return newData

I would like to make a numarray array that shares data with a Numeric array
and/or with a PIL Image.
As an example of the sort of thing I want to do:
>>> import Numeric, Image, ImageDraw
>>> a = Numeric.zeros((8,8), 'b')
>>> im = Image.frombuffer('L', a.shape[::-1], a)
>>> im.readonly = False
>>> d = ImageDraw.Draw(im)
>>> d.line((0,0,8,8), fill=255)
>>> a
array([[ 0, 0, 0, 0, 0, 0, 0, 255],
[ 0, 0, 0, 0, 0, 0, 255, 0],
[ 0, 0, 0, 0, 0, 255, 0, 0],
[ 0, 0, 0, 0, 255, 0, 0, 0],
[ 0, 0, 0, 255, 0, 0, 0, 0],
[ 0, 0, 255, 0, 0, 0, 0, 0],
[ 0, 255, 0, 0, 0, 0, 0, 0],
[255, 0, 0, 0, 0, 0, 0, 0]],'b')
So with Numeric, I can have bidirectional data sharing between an array and
an Image object. I have been unable to do the same using a numarray array.
Does anyone know whether there is a way to do this?
Chris Perkins