How to Find Function Values in Python

Introduction
What Does “Find Function Values” Really Mean?
Real-World Scenario: The Volatility-Adjusted Momentum Strategy
Methods to Compute Function Values Efficiently
Complete Implementation with Test Cases
Best Practices and Performance Tips
Conclusion

Introduction

In algorithmic trading, success isn’t about predicting the future — it’s about computing the right value at the right time.

Whether it’s a moving average, volatility index, or risk-adjusted return, every decision your bot makes starts with one question:

“What is the function value at this point?”

This article reveals how top traders use Python to efficiently compute function values over price arrays — not with complex math libraries, but with clean, fast, and battle-tested code.

What Does “Find Function Values” Really Mean?

It’s simple:
You have a function — like f(x) = (x - mean) / std — and you want to apply it to every element in an array of stock prices.

You’re not just calculating numbers.
You’re turning raw data into actionable signals:

Buy when volatility drops below the threshold
Sell when momentum spikes
Hold when risk exceeds tolerance

The key?
Don’t recalculate the same values over and over.

Real-World Scenario: The Volatility-Adjusted Momentum Strategy

Imagine you’re building a bot that trades based on relative price movement, not absolute price.

Your rule

Buy when today’s return is above the 5-day average return AND volatility is below the 10-day average.

You have

prices: daily closing prices
A function to compute daily returns: return = (p[i] - p[i-1]) / p[i-1]
A function to compute rolling volatility: std of last N returns

You don’t need AI. You don’t need news feeds.
You just need to find the function values — accurately and fast.

Methods to Compute Function Values Efficiently

1. Direct List Comprehension (Simple & Clean)

def compute_returns(prices):
    return [(prices[i] - prices[i-1]) / prices[i-1] for i in range(1, len(prices))]

def compute_volatility(returns, window=10):
    if len(returns) < window:
        return [0] * len(returns)
    return [sum(returns[i-window+1:i+1]) / window for i in range(window-1, len(returns))]

Perfect for small datasets. Easy to debug.

2. NumPy Vectorization (Fastest for Large Data)

import numpy as np

def compute_returns_numpy(prices):
    prices = np.array(prices)
    returns = np.diff(prices) / prices[:-1]  # Vectorized
    return returns

def compute_volatility_numpy(returns, window=10):
    if len(returns) < window:
        return np.zeros_like(returns)
    # Rolling std using convolution
    weights = np.ones(window) / window
    volatilities = np.convolve(np.abs(returns), weights, mode='valid')
    return np.pad(volatilities, (window-1, 0), constant_values=0)

3. Generator for Memory Efficiency

def returns_generator(prices):
    for i in range(1, len(prices)):
        yield (prices[i] - prices[i-1]) / prices[i-1]

# Use only when you need one value at a time
def find_signal(prices, threshold=0.02):
    returns = list(returns_generator(prices))
    avg_return = sum(returns[-5:]) / 5 if len(returns) >= 5 else 0
    return "BUY" if returns[-1] > avg_return > threshold else "HOLD"

Use when memory is tight (e.g., streaming data).

Complete Implementation with Test Cases

import numpy as np
import unittest

class VolatilityTrader:
    def __init__(self, window_return=5, window_volatility=10):
        self.window_r = window_return
        self.window_v = window_volatility

    def compute_returns(self, prices):
        """Compute daily percentage returns."""
        if len(prices) < 2:
            return []
        return [(prices[i] - prices[i-1]) / prices[i-1] for i in range(1, len(prices))]

    def compute_volatility(self, returns):
        """Compute rolling average absolute return (volatility proxy)."""
        if len(returns) < self.window_v:
            # Consistent with numpy version: pad initial values with 0.0
            return [0.0] * len(returns)
        vols = []
        for i in range(self.window_v - 1, len(returns)):
            window = returns[i - self.window_v + 1:i + 1]
            vol = sum(abs(r) for r in window) / self.window_v
            vols.append(vol)
        # Pad initial values to match the length of returns
        return [0.0] * (self.window_v - 1) + vols

    def generate_signals(self, prices):
        """Generate BUY/HOLD signals based on return vs. volatility."""
        
        # Minimum price length required to compute signals: max(R, V) + 1
        min_len = max(self.window_r, self.window_v) + 1
        if len(prices) < min_len:
            return ["HOLD"] * len(prices)

        returns = self.compute_returns(prices)
        volatilities = self.compute_volatility(returns)
        
        # Signals will have the same length as prices
        signals = ["HOLD"] * len(prices)
        
        # Start index for signal generation is min_len - 1, which corresponds to the 
        # first day where both windows (R and V) are fully formed.
        # This is where 'prices[i]' is first considered for a signal.
        start_index = min_len - 1
        
        for i in range(start_index, len(prices)):
            # Average Return is calculated over the *last* window_r returns (ending at return[i-1])
            # The returns array has length len(prices)-1. returns[i-1] is the return from prices[i-1] to prices[i]
            # The returns window should cover returns for prices[i-window_r] to prices[i-1]
            recent_avg_return = sum(returns[i-self.window_r:i]) / self.window_r
            
            # Volatility is calculated over the last window_v absolute returns (ending at return[i-1])
            # volatilities array is padded and has length len(prices)-1. 
            # volatilities[i-1] is the volatility ending on the return calculated up to price[i]
            current_volatility = volatilities[i-1]  # volatilities[i-1] corresponds to the volatility up to day i
            
            if recent_avg_return > 0.01 and current_volatility < 0.02:
                signals[i] = "BUY"

        return signals

    def generate_signals_fast(self, prices):
        """High-performance NumPy version."""
        if len(prices) < 2:
            return ["HOLD"] * len(prices)

        prices = np.array(prices)
        returns = np.diff(prices) / prices[:-1]
        abs_returns = np.abs(returns)

        # 1. Rolling average return (window_r)
        cumsum_r = np.cumsum(np.insert(returns, 0, 0))
        # The rolling average over returns[k:k+R] is computed.
        # avg_returns[i] is the average of returns[i:i+window_r].
        # Length is len(returns) - window_r + 1
        avg_returns_raw = (cumsum_r[self.window_r:] - cumsum_r[:-self.window_r]) / self.window_r

        # 2. Rolling volatility (window_v)
        cumsum_v = np.cumsum(np.insert(abs_returns, 0, 0))
        # avg_volatility_raw[i] is the average of abs_returns[i:i+window_v].
        # Length is len(abs_returns) - window_v + 1
        avg_volatility_raw = (cumsum_v[self.window_v:] - cumsum_v[:-self.window_v]) / self.window_v

        # 3. Alignment and Padding (Crucial Step)

        # The decision for prices[i] depends on a window of returns ENDING at returns[i-1].
        # In the original implementation:
        # - The first decision is at prices[max(R, V)].
        # - This decision uses the average return of returns[max(R, V)-R : max(R, V)]
        # - This decision uses the volatility ending at returns[max(R, V)]
        
        min_len = max(self.window_r, self.window_v)
        
        # We need to pad the raw arrays to match the length of prices (len(prices)).
        # Both arrays represent calculations over the returns array (len(prices)-1).
        
        # Padding for Avg Returns:
        # The first valid average return corresponds to the window ending at returns[window_r-1].
        # This decision is for prices[window_r].
        # We need window_r 'HOLD' signals before the first valid return calculation is available.
        # This pad is for the start of the signals.
        pad_r = self.window_r 
        padded_avg_returns = np.pad(avg_returns_raw, (pad_r, 0), constant_values=0)
        
        # Padding for Volatility:
        # The first valid volatility corresponds to the window ending at returns[window_v-1].
        # This decision is for prices[window_v].
        pad_v = self.window_v
        padded_avg_volatility = np.pad(avg_volatility_raw, (pad_v, 0), constant_values=0)
        
        # The final arrays should have the length of prices.
        # We need to consider the overlap: the final signal array is generated up to the 
        # length of prices.
        
        # Slice to the correct length and align:
        # Since the first signal is at index max(R,V), we slice both to that length
        # and then apply the logic.
        
        # Use the maximum required padding for alignment
        max_pad = max(self.window_r, self.window_v)
        
        # The array indices for the signal: [0, 1, ..., max_pad-1] will be "HOLD"
        # The signal for price[i] is determined by:
        # - padded_avg_returns[i] (which is the avg return ending at returns[i-1])
        # - padded_avg_volatility[i] (which is the avg volatility ending at returns[i-1])
        
        # Create a combined signal logic based on the longer padded array
        combined_signal_logic = np.where(
            (padded_avg_returns[max_pad:] > 0.01) & (padded_avg_volatility[max_pad:] < 0.02),
            "BUY", "HOLD"
        )
        
        # Prepend the initial "HOLD" signals
        initial_holds = np.array(["HOLD"] * max_pad)
        signals = np.concatenate((initial_holds, combined_signal_logic)).tolist()
        
        # Ensure the final signals list has the same length as the input prices
        if len(signals) < len(prices):
            # This handles cases where len(prices) is just slightly over max(R,V)
            signals += ["HOLD"] * (len(prices) - len(signals))
        elif len(signals) > len(prices):
            # This prevents over-shooting
            signals = signals[:len(prices)]

        return signals


class TestVolatilityTrader(unittest.TestCase):
    def setUp(self):
        # R=5, V=10. Signal starts at index 10.
        self.trader = VolatilityTrader(window_return=5, window_volatility=10)
        # Simulate rising price with low volatility
        self.prices = [100, 101, 102.5, 104, 105.5, 107, 108.5, 109, 110, 111, 112] # len=11
        # returns len=10
        # returns: ~[0.01, 0.0148, 0.0146, 0.0143, 0.0142, 0.0140, 0.0046, 0.0092, 0.0091, 0.0090]
        # avg_returns[5:10]: 
        # Day 10 (index 10): 
        # Avg Ret (last 5, returns[5:10]): avg([0.0140, 0.0046, 0.0092, 0.0091, 0.0090]) = 0.00918 (HOLD for 10)
        
        # Let's adjust prices to force a BUY signal on day 10
        self.prices_buy = [
            100, 101, 102.5, 104, 105.5, # Day 4, P=105.5
            107.5, # Day 5, Ret=0.0189
            109.5, # Day 6, Ret=0.0186
            111.5, # Day 7, Ret=0.0182
            113.5, # Day 8, Ret=0.0179
            115.5, # Day 9, Ret=0.0176
            117.5 # Day 10, Ret=0.0173
        ] # len=11
        # returns len=10: [0.01, 0.0148, 0.0146, 0.0143, 0.0189, 0.0186, 0.0182, 0.0179, 0.0176, 0.0173]
        # Avg Ret (last 5, returns[5:10]): avg([0.0186, 0.0182, 0.0179, 0.0176, 0.0173]) = 0.0179 > 0.01 (BUY)
        # Avg Vol (last 10, abs(returns)[0:10]): avg(abs(all returns)) = 0.0163 < 0.02 (BUY)

    def test_returns_computation(self):
        returns = self.trader.compute_returns(self.prices)
        self.assertAlmostEqual(returns[0], 0.01, places=4)
        self.assertAlmostEqual(returns[-1], (112 - 111) / 111, places=4) # 0.0090
        self.assertEqual(len(returns), len(self.prices) - 1)

    def test_signal_generation(self):
        signals = self.trader.generate_signals(self.prices_buy)
        # Should trigger BUY on day 10 (index 10) 
        self.assertEqual(signals[10], "BUY")
        self.assertEqual(signals[5], "HOLD")  # Too early (max(R,V)=10, so signal starts at index 10)
        
        # Test the day before the first potential signal (index 9)
        self.assertEqual(signals[9], "HOLD")
        
        # Test a case with not enough data
        signals_short = self.trader.generate_signals([100] * 10)
        self.assertEqual(len(signals_short), 10)
        self.assertTrue(all(s == "HOLD" for s in signals_short))

    def test_fast_version_matches_slow(self):
        slow = self.trader.generate_signals(self.prices_buy)
        fast = self.trader.generate_signals_fast(self.prices_buy)
        self.assertEqual(slow, fast)

        # Test with original prices that did not generate a BUY
        slow_no_buy = self.trader.generate_signals(self.prices)
        fast_no_buy = self.trader.generate_signals_fast(self.prices)
        self.assertEqual(slow_no_buy, fast_no_buy)

    def test_edge_cases(self):
        # Single price
        self.assertEqual(self.trader.generate_signals([100]), ["HOLD"])
        self.assertEqual(self.trader.generate_signals_fast([100]), ["HOLD"])
        
        # Two prices
        self.assertEqual(self.trader.generate_signals([100, 101]), ["HOLD", "HOLD"])
        self.assertEqual(self.trader.generate_signals_fast([100, 101]), ["HOLD", "HOLD"])


if __name__ == "__main__":
    # Demo
    trader = VolatilityTrader()
    # Prices that will generate a BUY signal on day 10 (index 10)
    prices = [100, 101, 102.5, 104, 105.5, 107.5, 109.5, 111.5, 113.5, 115.5, 117.5]
    signals = trader.generate_signals_fast(prices) # Use the fast version for the demo

    print(" VOLATILITY-ADJUSTED TRADING BOT")
    print(f"Window Return (R): {trader.window_r}, Window Volatility (V): {trader.window_v}")
    print(f"{'Day':<4} {'Price':<8} {'Signal':<8}")
    print("-" * 25)
    for i, (p, s) in enumerate(zip(prices, signals)):
        print(f"{i:<4} {p:<8} {s:<8}")

    print("\n Running tests...")
    unittest.main(argv=[''], exit=False, verbosity=1)

Best Practices and Performance Tips

Always validate input length before computing functions — avoid index errors.
Use NumPy for rolling windows — it’s 5–10x faster than pure Python loops.
Cache function results if inputs don’t change (e.g., static lookback windows).
Never modify original arrays — always return new ones.
Test edge cases: empty arrays, single values, inconsistent lengths.
Document what your function computes — “volatility” could mean std, range, or ATR.

Conclusion

Finding function values isn’t math — it’s decision-making in disguise. The best traders don’t guess trends. They compute them — precisely, repeatedly, and efficiently. Whether you’re using list comprehensions for clarity or NumPy for speed, the goal is the same:

Turn raw data into a signal your bot can trust.

Master this, and you’re no longer coding. You’re building self-executing financial logic. Start small. Test rigorously. Let the numbers speak.

Table of Contents