be*******@aol.com wrote in message news:<30**************************@posting.google. com>...

Suppose I define a trivial class composed of x and y coordinates and

create a Numeric array of instances of that class.

class xy:

def __init__(self,x=0.0,y=0.0):

self.x = x

self.y = y

def __repr__(self):

return ("%6.2f" % self.x) + (",%6.2f" % self.y)

from xy import xy

from Numeric import zeros,array,PyObject

n = 3

aa = array([xy() for i in xrange(n)], PyObject)

aa[1] = xy(5.0,25.0)

print aa

# not legal -- print aa.x

The output of this program is

[ 0.00, 0.00 5.00, 25.00 0.00, 0.00 ] .

I would like to be able to get an array [0.00 5.00 0.00] corresponding

to the x component of array aa using the syntax aa.x, but this is not

correct Python. Array slices of components would also be nice. I

could write a function to return such an array, but I doubt that this

would be efficient in CPU time or memory. I wonder if this capability

could be added to Numarray, the successor of Numeric. Otherwise, it

may be better to write numerical codes using parallel arrays (one for

x, one for y) instead of classes, and the benefits of classes are

lost.

Here's a way to kinda get what you want:

from numarray import zeros, Float

class space(object):

def __init__(self, n=3):

self.points = zeros((n,2), Float)

def __getitem__(self, i):

return xy(self.points[i])

def __setitem__(self, i, (x,y)):

self.points[i,0] = x

self.points[i,1] = y

def __repr__(self):

return repr(self.points)

# or, '\n'.join([repr(p) for p in self.points])

x = property(lambda self: self.points[:,0])

y = property(lambda self: self.points[:,1])

class xy(object):

def __init__(self, loc):

self.loc = loc

def __repr__(self):

return '%2.6f, %2.6f' % (self.x, self.y)

def _get_x(self): return self.loc[0]

def _set_x(self, value): self.loc[0] = value

x = property(_get_x, _set_x)

def _get_y(self): return self.loc[1]

def _set_y(self): self.loc[1] = value

y = property(_get_y, _set_y)

n = 3

aa = space(n)

aa[1] = (5.0, 25.0)

print aa

print aa.x

---

Using the array slicing, "array[:,i]" seems to be pretty efficient to

me. You can also use that syntax for setting values. The xy class

now is just a convenience wrapper/pointer to its position in space...

One improvement on this might be to allow slicing of space so you can

do something like:

a,b,c = aa[100:103] # to get 3 discreet points

aa[50:55] = [(1.,2.), (2.,3.), (3.,4.), (4.,5.), (5.,6.)] # to

set multiple points

--T