# [Numpy-discussion] Is there a memory-efficient alternative to choose?

Josh Hykes jmhykes@ncsu....
Wed Mar 9 09:58:06 CST 2011

```>
> Would the "out" keyword of np.choose be a possible solution? Using that,
> you should be able to create the properies_map in place, and perhaps you can
> then do the multiplication with the state variables in place also:

Thanks, Lutz, for this suggestion. I hadn't thought of using the "out"
keyword. This should do the trick for a number of instances in my code.

Unfortunately, I'm not sure that it will work for the more complicated
expressions. The problem is that the properties_map array can be larger than
the answer array. For example, each property could be a matrix that gets
multiplied by a vector of state variables in each cell. For example:

import numpy as np

p0 = np.array([[1., 0.], [1., 1.]]) # matrix properties
p1 = np.array([[1., 1.], [0., 1.]])

properties = {0: p0, 1: p1}

mesh_map = np.array([[0,0,0,0],
[0,1,1,0],
[0,1,1,0],
[0,0,0,0]])

state_variables = np.arange(mesh_map.size*2).reshape(mesh_map.shape+(2,))

for i in range(mesh_map.shape[0]):
for j in range(mesh_map.shape[1]):
m = mesh_map[i,j]

I was envisioning a sort of generator function defined through Numpy that
would operate at C speed, maybe something like:

properties_map = np.choose_generator(mesh_map, [properties[0],
properties[1]])

This may not be possible without using f2py or Cython. I just figured I'd
ask the experts before going that route.

Thanks again.

-Josh

On Tue, Mar 8, 2011 at 4:53 PM, Lutz Maibaum <lutz.maibaum@gmail.com> wrote:

> On Mar 8, 2011, at 11:56 AM, Josh Hykes wrote:
> > At some point in my code, I need to do a cell-wise multiplication of the
> properties with a state variable. The ideal method would (1) be fast (no
> Python loops) and (2) not waste memory constructing an entire property map.
> My best attempt using choose does (1) but not (2).
>
> Would the "out" keyword of np.choose be a possible solution? Using that,
> you should be able to create the properies_map in place, and perhaps you can
> then do the multiplication with the state variables in place also:
>
> import numpy as np
> properties = {0: 0.5, 1: 2.} # 2 materials
> mesh_map = np.array([[0,0,0,0], [0,1,1,0], [0,1,1,0], [0,0,0,0]]) # 4x4
> mesh
> state_variables = np.arange(mesh_map.size).reshape(mesh_map.shape) # fake
> state variables
> answer = np.empty (mesh_map.shape, np.float)  # do this only once with
> dtype of properties