I suspect what you are looking for is the new df.expanding(..., method='table') in the upcoming pandas=1.3 (see "Other enhancements").

In the meantime, you can do it "by hand", using a loop (sorry):

xy = df.values
df['c1 c2 c3'.split()] = np.stack([
    func2(*xy[:n].T) if n >= 3 else np.empty(3)*np.nan
    for n in range(xy.shape[0])
])

Example:

np.random.seed(0)
df = pd.DataFrame(np.random.rand(10, 2).round(2), 
                  columns=['Input', 'Response'])

# the code above, then

>>> df
   Input  Response         c1         c2        c3
0   0.55      0.72        NaN        NaN       NaN
1   0.60      0.54        NaN        NaN       NaN
2   0.42      0.65        NaN        NaN       NaN
3   0.44      0.89 -22.991453  22.840171 -4.887179
4   0.96      0.38 -29.759096  29.213620 -6.298277
5   0.79      0.53   0.454036  -1.369701  1.272156
6   0.57      0.93   0.122450  -0.874260  1.113586
7   0.07      0.09  -1.010312   0.623331  0.696287
8   0.02      0.83  -2.687387   2.995143 -0.079214
9   0.78      0.87  -1.425030   1.294210  0.442684

I usually do this using zip:

>>> df = pd.DataFrame([[i] for i in range(10)], columns=['num'])
>>> df
    num
0    0
1    1
2    2
3    3
4    4
5    5
6    6
7    7
8    8
9    9

>>> def powers(x):
>>>     return x, x**2, x**3, x**4, x**5, x**6

>>> df['p1'], df['p2'], df['p3'], df['p4'], df['p5'], df['p6'] = \
>>>     zip(*df['num'].map(powers))

>>> df
        num     p1      p2      p3      p4      p5      p6
0       0       0       0       0       0       0       0
1       1       1       1       1       1       1       1
2       2       2       4       8       16      32      64
3       3       3       9       27      81      243     729
4       4       4       16      64      256     1024    4096
5       5       5       25      125     625     3125    15625
6       6       6       36      216     1296    7776    46656
7       7       7       49      343     2401    16807   117649
8       8       8       64      512     4096    32768   262144
9       9       9       81      729     6561    59049   531441

You could use df.itertuples to iterate through each row, and use a list comprehension to reshape the data into the desired form:

import pandas as pd

df = pd.DataFrame( {"name" : ["John", "Eric"], 
               "days" : [[1, 3, 5, 7], [2,4]]})
result = pd.DataFrame([(d, tup.name) for tup in df.itertuples() for d in tup.days])
print(result)

yields

   0     1
0  1  John
1  3  John
2  5  John
3  7  John
4  2  Eric
5  4  Eric

Divakar's solution, using_repeat, is fastest:

In [48]: %timeit using_repeat(df)
1000 loops, best of 3: 834 µs per loop

In [5]: %timeit using_itertuples(df)
100 loops, best of 3: 3.43 ms per loop

In [7]: %timeit using_apply(df)
1 loop, best of 3: 379 ms per loop

In [8]: %timeit using_append(df)
1 loop, best of 3: 3.59 s per loop

Here is the setup used for the above benchmark:

import numpy as np
import pandas as pd

N = 10**3
df = pd.DataFrame( {"name" : np.random.choice(list('ABCD'), size=N), 
                    "days" : [np.random.randint(10, size=np.random.randint(5))
                              for i in range(N)]})

def using_itertuples(df):
    return  pd.DataFrame([(d, tup.name) for tup in df.itertuples() for d in tup.days])

def using_repeat(df):
    lens = [len(item) for item in df['days']]
    return pd.DataFrame( {"name" : np.repeat(df['name'].values,lens), 
                          "days" : np.concatenate(df['days'].values)})

def using_apply(df):
    return (df.apply(lambda x: pd.Series(x.days), axis=1)
            .stack()
            .reset_index(level=1, drop=1)
            .to_frame('day')
            .join(df['name']))

def using_append(df):
    df2 = pd.DataFrame(columns = df.columns)
    for i,r in df.iterrows():
        for e in r.days:
            new_r = r.copy()
            new_r.days = e
            df2 = df2.append(new_r)
    return df2

This addresses the problem, not the general issue of passing multiple columns: I would use groupby and cummax, and then see whether we hit a new value. For example:

grouped = df.groupby("id")["value"]
cummax = grouped.cummax()
cummax_is_new_value = cummax != cummax.groupby(df.id).shift()
df["new_max"] = cummax_is_new_value.astype(int)

gives me

>>> df
    id  value  new_max
0    0      1        1
1    0      3        1
2    0      2        0
3    0      5        1
4    0      4        0
5    1      4        1
6    1      3        0
7    1      2        0
8    1      1        0
9    1      5        1
10   2      1        1
10   2      1        0
10   2      0        0
10   2      1        0
10   3      1        1

Originally I was only checking whether the value was the same as the previous value, but that failed on cases like [1, 0, 1], where the second 1 is both equal to the cumulative maximum and not the same as the previous value. This way we're always working with the grouped cumulative values, and so we really are only picking up the new cumulative values by group.

An possible solution is to make the expanding part of the function, and use GroupBy.apply:

def foo1(_df):
    return _df['x1'].expanding().max() * _df['x2'].expanding().apply(lambda x: x[-1], raw=True)

df['foo_result'] = df.groupby('group').apply(foo1).reset_index(level=0, drop=True)
print (df)
  group  time   x1  x2  foo_result
0     A     1   10   1        10.0
3     B     1  100   2       200.0
1     A     2   40   2        80.0
4     B     2  200   0         0.0
2     A     3   30   1        40.0
5     B     3  300   3       900.0

This is not a direct solution to the problem of applying a dataframe function to an expanding dataframe, but it achieves the same functionality.