transfer undefined class methods to attribute's method [Numeric array]

Maarten van Reeuwijk maarten at
Fri Feb 6 15:35:07 CET 2004

I am constructing a "placeholder array" to mimick Numeric arrays. I have a
3D regular structured domain, so I can describe the axis with 3 1D arrays
x[], y[] and z[]. All the variables defined on this field (temperature,
velocity) are 3D-fields, and to treat everything the same, I want to have
x,y and z also as a 3d-array. However, as one field is typically 100 Mb, I
do not want to create these arrays, but instead define a class that mimicks

I have succeeded in doing this (see code below), but now I want to transfer
any unknown class methods to the in-line created variable, something like:

def process_unknownmethod(self, method, args)

How do I do this in python?

TIA, Maarten

Here's the class (sorry for the long class)

from Numeric import *

class PlaceHolder:
        def __init__(self, axis, dims, arr):
                self.axis = axis
                self.arr = arr
                self.dims = dims

        def __interpretkey(self, axis, key):
                if type(key) == int:
                        sl = slice(key, key+1,1)
                        # interpret the slice object
                        start = key.start
                        if (start == None): 
                                if not (key.stop == None):
                                        start = key.stop
                                        start == 0
                        if start < 0:
                                if start > - self.dims[axis]:
                                        start = self.dims[axis] + start
                                        start = 0

                        stop = key.stop
                        if stop == None or stop == sys.maxint:
                                stop = self.dims[axis]
                        if stop < 0:
                                if stop > - self.dims[axis]:
                                        stop = self.dims[axis] + stop
                                        stop = 0

                        step = key.step
                        if not step: step = 1

                        sl = slice(start, stop, step)

                return sl

        def __getitem__(self, key):
                sl = []

                # if it's only one argument, make it into a tuple
                if not ((type(key) == tuple) or (type(key) == list)):
                        key = (key,)

                # determine ranges
                for i, rng in enumerate(key):
                        sl.append(self.__interpretkey(i, rng))

                # extend for missing dimensions
                for i in range(len(key), len(self.dims)):
                        sl.append(slice(0, self.dims[i], 1))

                # swap values for indices
                sl[0], sl[self.axis] = sl[self.axis], sl[0]
                base = self.arr[sl[0]]

                # create an array
                for n, i in enumerate(sl):
                        l = int(abs(float(i.stop - i.start)) / abs(i.step)+0.5)
                        if n > 0:
                                base = add.outer(base, zeros(l))

                base = swapaxes(base, 0, self.axis)

                # remove the dimensions of length 1

                rdims = []
                for i in range(rank(base)):
                        if base.shape[i] <= 1:


                for i in rdims:
                        base = add.reduce(base, i)

                return base

# example starts here

a = arange(10.)
y = PlaceHolder(1, [10, 10, 10], a)

print y[1, :, 10]
print y[1, 3]

Maarten van Reeuwijk                    Thermal and Fluids Sciences
Phd student                             dept. of Multiscale Physics                 Delft University of Technology

More information about the Python-list mailing list