title: Python - faster alternative to 'for' loops
body: <p>I am trying to construct a binomial lattice model in Python. The idea is that there are multiple binomial lattices and based on the value in particular lattice, a series of operations are performed in other lattices.
  These operations are similar to 'option pricing model' ( Reference to Black Scholes models) in a way that calculations start at the last column of the lattice and those are iterated to previous column one step at a time.
  For example,
  If I have a binomial lattice with n columns,
  1. I calculate the values in nth column for a single or multiple lattices.
  2. Based on these values, I update the values in (n-1)th column in same or other binomial lattices
  3. This process continues until I reach the first column.</p>
  
  <p>So in short, I cannot process the calculations for all of the lattice simultaneously as value in each column depends on the values in next column and so on.</p>
  
  <p>From coding perspective,
  I have written a function that does the calculations for a particular column in a lattice and outputs the numbers that are used as input for next column in the process.</p>
  
  <pre><code>def column_calc(StockPrices_col, ConvertProb_col, y_col, ContinuationValue_col, ConversionValue_col, coupon_dates_index, convert_dates_index ,
                  call_dates_index, put_dates_index, ConvertProb_col_new, ContinuationValue_col_new, y_col_new,tau, r, cs, dt,call_trigger,
                  putPrice,callPrice):
  
  for k in range(1, n+1-tau):
  
       ConvertProb_col_new[n-k] = 0.5*(ConvertProb_col[n-1-k] + ConvertProb_col[n-k])
  
       y_col_new[n-k] =  ConvertProb_col_new[n-k]*r + (1- ConvertProb_col_new[n-k]) *(r + cs) 
  
       # Calculate the holding value
       ContinuationValue_col_new[n-k] = 0.5*(ContinuationValue_col[n-1-k]/(1+y_col[n-1-k]*dt) +  ContinuationValue_col[n-k]/(1+y_col[n-k]*dt))
  
       # Coupon payment date
       if np.isin(n-1-tau, coupon_dates_index) == True:
  
           ContinuationValue_col_new[n-k] = ContinuationValue_col_new[n-k] + Principal*(1/2*c);
  
       # check put/call schedule
       callflag = (np.isin(n-1-tau, call_dates_index)) &amp; (StockPrices_col[n-k] &gt;= call_trigger)
       putflag = np.isin(n-1-tau, put_dates_index)
       convertflag = np.isin(n-1-tau, convert_dates_index)
  
       # if t is in call date
       if (np.isin(n-1-tau, call_dates_index) == True) &amp; (StockPrices_col[n-k] &gt;= call_trigger):
  
           node_val = max([putPrice * putflag, ConversionValue_col[n-k] * convertflag, min(callPrice, ContinuationValue_col_new[n-k])] )
       # if t is not call date    
       else:
  
           node_val = max([putPrice * putflag, ConversionValue_col[n-k] * convertflag, ContinuationValue_col_new[n-k]] )
  
  
       # 1. if Conversion happens
       if node_val == ConversionValue_col[n-k]*convertflag:
           ContinuationValue_col_new[n-k] = node_val
           ConvertProb_col_new[n-k] = 1
  
       # 2. if put happens
       elif node_val == putPrice*putflag:
           ContinuationValue_col_new[n-k] = node_val
           ConvertProb_col_new[n-k] = 0
  
       # 3. if call happens
       elif node_val == callPrice*callflag:
           ContinuationValue_col_new[n-k] = node_val
           ConvertProb_col_new[n-k] = 0
  
       else:
           ContinuationValue_col_new[n-k] = node_val
  
  
  return ConvertProb_col_new, ContinuationValue_col_new, y_col_new
  </code></pre>
  
  <p>I am calling this function for every column in the lattice through a for loop.
  So essentially I am running a nested for loop for all the calculations. </p>
  
  <p>My issue is - This is very slow.
  The function doesn't take much time. but the second iteration where I am calling the function through the for loop is very time consuming ( avg. times the function will be iterated in below for loop is close to 1000 or 1500 ) It takes almost 2.5 minutes to run the complete model which is very slow from standard modeling standpoint.
  As mentioned above, most of the time is taken by the nested for loop shown below:</p>
  
  <pre><code>temp_mat = np.empty((n,3))*(np.nan)
  temp_mat[:,0] = ConvertProb[:, n-1]
  temp_mat[:,1] = ContinuationValue[:, n-1]
  temp_mat[:,2] = y[:, n-1]
  
  ConvertProb_col_new = np.empty((n,1))*(np.nan)
  ContinuationValue_col_new = np.empty((n,1))*(np.nan)
  y_col_new = np.empty((n,1))*(np.nan)
  
  
  for tau in range(1,n):    
  
      ConvertProb_col = temp_mat[:,0]
      ContinuationValue_col = temp_mat[:,1]
      y_col = temp_mat[:,2]
  
      ConversionValue_col = ConversionValue[:, n-tau-1]
      StockPrices_col = StockPrices[:, n-tau-1]
  
  
  
      out = column_calc(StockPrices_col, ConvertProb_col, y_col, ContinuationValue_col, ConversionValue_col, coupon_dates_index, convert_dates_index ,call_dates_index, put_dates_index, ConvertProb_col_new, ContinuationValue_col_new, y_col_new, tau, r, cs, dt,call_trigger,putPrice,callPrice)
  
      temp_mat[:,0] = out[0].reshape(np.shape(out[0])[0],)
      temp_mat[:,1] = out[1].reshape(np.shape(out[1])[0],)
      temp_mat[:,2] = out[2].reshape(np.shape(out[2])[0],)
  
  #Final value
  print(temp_mat[-1][1])
  </code></pre>
  
  <p>Is there any way I can reduce the time consumed in nested for loop? or is there any alternative that I can use instead of nested for loop.
  Please let me know. Thanks a lot !!!</p>