Dynamic function building in Python

Question

I need to create a function for an arbitrary number of peaks to pass to a least square fitting routine. For each peak there is an extra term in the function, i.e.

One term with a value at 50 returns a function: f(p, x) = p[0]*50

Two terms with values at 50, 60 returns a function: f(p, x) = p[0]*50 + p[1]*60*x

Three terms with values at 50, 60, 70 returns: f(p, x) = p[0]*50 + p[1]*60*x + p[2]*70*x^2

etc.

A couple of naive attempts are shown below,

def foo(vals):
    fn = lambda p, x: 0
    i = 0
    for v in vals:
        fn = lambda p, x : fn(p, x) + p[i] * v * x**i
        i += 1
    return fn
# Causes a recursion error (I think)

Second attempt ...

def bar(vals):
    terms = []
    i = 0
    for v in vals:
        terms.append(lambda x, p: p[i] * v * x**i)
        i += 1
    def fn(x, p):
        tvals = [t(x, p) for t in terms]
        sum = 0
        for t in terms:
            sum = sum + t(x, p)
        return sum
    return fn
# Generates the wrong values

I suspect that this is a problem with referencing, i.e. Python refers to list declarations etc. but this is a little complicated to untangle - any help would be appreciated!

Can you provide a test case, showing what you're expecting to get (and what you're getting in the second case)? — NPE
– NPE, Commented Dec 7, 2010 at 13:17
Yeah it's a bit hard to guess what you want, especially since the first does just overwrite fn alot ... — Jochen Ritzel
– Jochen Ritzel, Commented Dec 7, 2010 at 13:22
Ah, It seems in the second attempt I copied the code when I was trying to debug, it shouldn't return a list, it should return the sum of that list ... Also I explained the desired outcome a little better — Brendan
– Brendan, Commented Dec 7, 2010 at 14:18

unutbu · Accepted Answer · 2010-12-07 14:27:55Z

2

How about:

def foo(vals):
    def f(p,x):
        result=0
        for i,(av,ap) in enumerate(zip(vals,p)):
            result+=av*ap*(x**i)
        return result
    return f

print(foo([50])([2],3))
# f(p,x)=50*2
# 100
print(foo([50,60])([2,3],4))
# f(p,x)=50*2+60*3*x
# 820

answered Dec 7, 2010 at 14:27

unutbu

886k197 gold badges1.9k silver badges1.7k bronze badges

Sign up to request clarification or add additional context in comments.

Comments

Community · Accepted Answer · 2017-05-23 11:47:48Z

1

You can write the whole thing as a function that returns a closure:

def make_function(vals):
    def evaluate(x,p):
        return sum(p[i] * v * x**i
                   for i,v in enumerate(vals))
    return evaluate

The issue you're running into with the terms functions comes up regularly. I wrote a long explanation about this problem before, hopefully it will be helpful.

Btw, foo and bar are syntactic variables, which means they are used to explain the syntax. For implementation problems you should really use good names that mean something in the domain, that often makes the problem much easier to understand.

edited May 23, 2017 at 11:47

CommunityBot

11 silver badge

answered Dec 7, 2010 at 13:34

Jochen Ritzel

108k33 gold badges205 silver badges195 bronze badges

2 Comments

Brendan Over a year ago

Hmm, this returns a generator not a function ... it needs to be a function (in the mathematical sense) for the fitting routine to work

Jochen Ritzel Over a year ago

@Brendan yeah i wrote what you had as 2nd attempt before. As you can see it doesnt take much to transform it to a sum.

score 1 · Accepted Answer · 2010-12-07 15:19:17Z

1

Closures don't capture the values of variables in outer scopes at the time of their creation, they really capture these variables. [lambda: i for i in range(5)] gives you five functions that all return 4, because they all refer to the same i (which is 4 when iteration ends). You can hack around this by using default arguments (which are bind values at function definition time): [lambda i=i: i for i in range(5)] works as expected.

Also, use enumerate. This, together with making fn a lambda, can reduce your code to just two, imo equally readable, lines (I'm assuming the second version, the first seems broken in more ways, as indicated in comments):

def bar(vals):
    terms = [lambda x, p, i=i, v=v: p[i] * v * x**i for i, v in enumerate(vals)]
    return lambda x, p: sum(term(x, p) for term in terms)

edited Dec 7, 2010 at 15:19

answered Dec 7, 2010 at 13:22

user395760

3 Comments

Brendan Over a year ago

Each of these terms give the right value (although it is the sum of the terms I am after - my bad, see question comments) - I can put this in a for loop to sum them up - as in the question - but is there a more concise way to do this?

user395760 Over a year ago

@Brendan: Sure, the sum built-in.

Brendan Over a year ago

Ah, I didn't realise there was such a thing in plain Python (I usually use Numpy) - if I could also nominate this as a second answer I would

John La Rooy · Accepted Answer · 2010-12-07 20:53:34Z

0

A simple modification stores a reference to each fn in a default parameter

def foo(vals):
    fn = lambda p, x: 0
    i = 0
    for v in vals:
        fn = lambda p, x, f=fn, i=i: f(p, x) + p[i] * v * x**i
        i += 1
    return fn

edited Dec 7, 2010 at 20:53

answered Dec 7, 2010 at 13:22

John La Rooy

306k54 gold badges378 silver badges513 bronze badges

1 Comment

John La Rooy Over a year ago

@Brendan, yeah needs to be closed on i too.

Collectives™ on Stack Overflow

Dynamic function building in Python

4 Answers 4

Comments

2 Comments

3 Comments

1 Comment

Your Answer

Linked

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

2 Comments

3 Comments

1 Comment

Your Answer

Sign up or log in

Post as a guest

Linked

Related