Applying several functions to each row of an array

So, let's see if I understand your question.

1. You want to map elements of your matrix to a new matrix such that:
   • 0 maps to 1
   • x>0 maps to funPos(x)
   • x<0 maps to funNeg(x)
2. You want to calculate the product of all elements in the rows this new matrix.

So, here's how I would go about doing it:

1:

def myFun(a):
    if a==0:
        return 1
    if a>0:
        return funPos(a)
    if a<0:
        return funNeg(a)

newFun = np.vectorize(myFun)
newArray = newFun(myArray)

And for 2:

np.prod(newArray, axis = 1)

Edit: To pass the index to funPos, funNeg, you can probably do something like this:

# Python 2.7
r,c = myArray.shape
ctr = -1       # I don't understand why this should be -1 instead of 0
def myFun(a):
    global ctr
    global c
    ind = ctr % c
    ctr += 1
    if a==0:
        return 1
    if a>0:
        return funPos(a,l[ind])
    if a<0:
        return funNeg(a,l[ind])

I think this numpy function would be helpful to you

numpy.apply_along_axis

Here is one implementation. Also I would warn against checking if the sum of the array is 0. Comparing floats to 0 can give unexpected behavior due to machine accuracy constraints. Also if you have -5 and 5 the sum is zero and I'm not sure thats what you want. I used numpy's any() function to see if anything was nonzero. For simplicity I also pulled your list (my_list) into global scope.

import numpy as np


my_list = 1.1, 2., 3.4

def func_pos(val1, val2):
    return val1 * val2

def func_neg(val1, val2):
    return val1 *(val2 + 1)


def my_generator(row):
    for i, a in enumerate(row):
        if a > 0:
            yield func_pos(a, my_list[i])
        elif a < 0:
            yield func_neg(a, my_list[i])
        else:
            yield 1


def reduce_row(row):
    if not row.any():
        return 1.0
    else:
        return np.prod(np.fromiter(my_generator(row), dtype=float))


def main():
    myArray = np.array([
            [ 0.        ,  0.        ,  0.        ],
            [ 0.32, -6.79,  0.        ],
            [ 0.        ,  0.        ,  0.        ],
            [ 0.        ,  1.5        ,  0.        ],
            [ 0.        ,  0.        , -1.71]])
    return np.apply_along_axis(reduce_row, axis=1, arr=myArray)

There are probably faster implmentations, I think apply_along_axis is really just a loop under the covers.

I didn't test, but I bet this is faster than what you started with, and should be more memory efficient.

I've tried your example with the masking function of numpy arrays. However, I couldn't find a solution to replace the values in your array by funPos or funNeg.

So my suggestion would be to try this using pandas instead as it conserves indices while masking.

See my example:

import numpy as np
import pandas as pd

def funPos(a, b):
    return a * b
def funNeg(a, b):
    return a * (b + 1)

myPosFunc = np.vectorize(funPos) #vectorized form of funPos
myNegFunc = np.vectorize(funNeg) #vectorized form of funNeg

#Input
I = [1.0, 2.0, 3.0]    
x = pd.DataFrame([
    [ 0.,0.,0.],
    [ 0.32, -6.79,  0.],
    [ 0.,0.,0.],
    [ 0.,1.5,0.],
    [ 0.,0., -1.71]])

b = pd.DataFrame(myPosFunc(x[x>0], I)) #calculate all positive values
c = pd.DataFrame(myNegFunc(x[x<0], I)) #calculate all negative values   
b = b.combineMult(c) #put values of c in b
b = b.fillna(1) #replace all missing values that were '0' in the raw array
y = b.product() #multiply all elements in one row

#Output
print ('final result')
print (y)
print (y.tolist())