Quant Trading Accelerator (Full Course) - Part 2: Arrays

Main ideas and lessons (Part 2: Arrays)

Arrays as the foundation for quant trading with AI/ML

• Arrays are a fundamental building block for quant trading with AI/ML
  • In Python, the concept is commonly represented as a list.
  • Arrays are used to store and manipulate financial time series data (e.g., sequences of prices).

Core array operations

Creation / representation

• Example: represent a price time series as an array of numbers.
• You can print/inspect the structure and see what Python recognizes it as (list ↔ array).

Length

• Arrays have a measurable length, which matters when the exchange provides an unknown number of data points.

Indexing (accessing elements)

• Zero-based indexing
  • Index 0 is the first element.
• Negative indexing
  • -1 is the last element, -2 is the second-to-last, etc.
• Bounds checking
  • Accessing an index outside the valid range raises an “index out of range” error.

Updating elements

• Elements can be replaced by index.
• None is commonly used as a null/missing value in market data when some prices are missing.
• Updates support both positive and negative indices (e.g., update the first element vs. the last element).

Removing elements

• pop() removes elements (often from the tail/end).
• Removing from the front/beginning requires shifting remaining elements, which is slower.
• Pop details:
  • pop() at the end is fast (no shifting).
  • Popping/erasing at the beginning is slow due to shifting many elements.
  • Caveat: pop() returns the removed value, while some other deletion approaches may not.

Performance guidance (important for large datasets)

• Removing from the beginning of a huge array (e.g., hundreds of millions of elements) is much slower.
• Removing from the end is extremely fast.
• Rule of thumb: Prefer removing from the end of arrays/lists for better scaling behavior.

Adding elements

• Add to an empty array:
  • Insert single values via direct syntax/methods.
• Add multiple elements at once:
  • Pass an array/collection of values in one operation.

Homogeneous vs. inhomogeneous arrays

• Inhomogeneous arrays
  • Mixed data types in one array (e.g., float + string + boolean).
  • Considered undesirable for quant ML workflows.
• Homogeneous arrays
  • All elements share the same data type (commonly floats / numeric types).
  • Benefits:
    • Enables CPU/SIMD optimizations and consistent computation behavior.
    • Important for quant trading AI/ML performance.

Loops pair naturally with arrays

• range(n) loop
  • Loops n times; indices start at 0.
• Looping through array elements
  • Example pattern: for x in prices: processes each element.
• Practical quant example
  • Given a list of trade P&Ls, loop to sum them into total P&L.
• Conceptual note
  • Libraries like pandas/polars often do equivalent operations under the hood using vectorized array computation rather than manual element updates.

---

Numpy arrays: why they matter

Numpy usage

• Import NumPy (commonly aliased), e.g., import numpy as np.
• Create a large homogeneous array (e.g., an array of ones).

Performance justification (empirical proof)

• Using NumPy’s operations (like sum) is much faster than Python’s generic summation approaches.

Reasons given

• Homogeneous numeric arrays enable:
  • SIMD parallelization on CPUs (similar motivation to GPU acceleration).
  • Highly optimized computation because NumPy operations are implemented in C.

---

Financial application: logarithms and log returns

Logarithm intuition (continuous compounding)

• A logarithm is the inverse of an exponential.

• Continuous compounding example:

  • Instead of looping year-by-year, compute analytically: capital * (1.05 ** t)

• Doubling-time:

  • Solve for t analytically using logs (avoid brute-force looping).
  • Use log algebra to compute the time needed to double investment.

Why “returns” instead of absolute changes

• Returns normalize performance:
  • A $100 profit means different things depending on starting capital (e.g., from $50 vs. from $99).
• Returns are a unitless measure of scale.

Log returns: properties and why they’re used

• Log returns show asymmetry compared to simple returns (e.g., +20% vs. -20% absolute effects).
• Log returns provide:
  • Symmetry (sign-flip-like behavior in log space)
  • Time additivity
    • Cumulative log return across multiple periods is obtained by summing log returns.

---

Exercises presented (methodology/list format)

Exercise 1: Average log return

• Goal: compute the arithmetic mean of a list of provided log returns.
• Instructions:
  • Initialize an accumulator variable (start at 0).
  • Use a loop over the log return list (do not hardcode/manual average).
  • Sum values and divide by the number of elements.
• Test condition:
  • The computed average log return must equal 0.0828.

Exercise 2: Total log returns and reconstruction check

• Goal: compute the total (sum) of log returns using a loop.
• Instructions:
  • Start from a portfolio path (example: 100 → 120 → 100 → 80 → 155).
  • Loop over consecutive portfolio values to compute each period’s log return.
  • Sum all log returns into a total.
• Correctness test:
  • exp(sum_of_log_returns) should equal the final portfolio value: 155.

Exercise 3: Cumulative log returns

• Goal: compute cumulative log returns over time (a running accumulation).
• Instructions:
  • For each time step:
    • Compute the log return for that step.
    • Maintain a cumulative value:
      • cumulative[0] = log_return[0]
      • cumulative[i] = cumulative[i-1] + log_return[i]
  • Produce the sequence of cumulative log returns.
• Validation:
  • Output must match the provided “expected” cumulative log return sequence.
• Why it matters:
  • This cumulative behavior is a common algorithm underlying pandas/polars computations.

---

Speakers / sources featured

• Primary speaker: the instructor narrating the course (begins with “Hello, welcome back…”), author of the Quant Trading Accelerator video.
• Course/channel sources mentioned:
  • Python (lists and loop behavior)
  • NumPy (NumPy arrays and optimized operations)
  • pandas and polars (vectorized array computations under the hood)
  • Patreon supporters (credited for funding/support; not named individually)