Quant - Financial Data API for Elixir

A quantitative analysis library that brings standardized financial data access and technical analysis to the Elixir ecosystem, leveraging the power of Explorer DataFrames and Polars for high-performance data processing.

The Problem

Financial data comes from many providers (Yahoo Finance, Binance, Alpha Vantage, etc.), each with different APIs, data formats, and quirks. This creates several challenges:

1. Inconsistent APIs: Different parameter names and formats for each provider
2. Varying Data Structures: Each provider returns data in different formats
3. Cross-Provider Analysis: Comparing data from multiple sources is complex
4. Missing Indicators: Need to implement technical indicators from scratch
5. Performance: Processing large datasets requires efficient data structures

Quant solves these problems with a unified API that works consistently across all providers.

Core Features

1. Standardized Data Access

All providers return data in an identical 12-column DataFrame:

# Yahoo Finance - stocks
{:ok, stock_df} = Quant.Explorer.history("AAPL",
  provider: :yahoo_finance,
  interval: "1d",
  period: "1y"
)

# Binance - cryptocurrency
{:ok, crypto_df} = Quant.Explorer.history("BTCUSDT",
  provider: :binance,
  interval: "1d",
  period: "1y"
)

# Both return identical DataFrame structure:
# [:symbol, :timestamp, :open, :high, :low, :close, :volume,
#  :adjusted_close, :market_cap, :provider, :currency, :timezone]

2. Technical Indicators (Python-Validated)

Six core indicators implemented with exceptional accuracy:

# Calculate RSI (100% accuracy vs Python)
df = Quant.Indicators.rsi(df, period: 14)

# Double Exponential Moving Average (99.96% accuracy)
df = Quant.Indicators.dema(df, period: 20)

# Hull Moving Average (100% accuracy)
df = Quant.Indicators.hma(df, period: 9)

# Kaufman Adaptive Moving Average (100% accuracy)
df = Quant.Indicators.kama(df, period: 10)

# Triple Exponential Moving Average (99.9988% accuracy)
df = Quant.Indicators.tema(df, period: 30)

# Weighted Moving Average (100% accuracy)
df = Quant.Indicators.wma(df, period: 10)

Each indicator is validated against Python implementations (pandas/numpy) to ensure accuracy.

3. Multi-Provider Support

Unified interface for all providers:

providers = [
  :yahoo_finance,    # Stocks, ETFs, indices
  :binance,          # Cryptocurrency
  :alpha_vantage,    # Stocks with fundamental data
  :coingecko,        # Cryptocurrency market data
  :twelve_data       # Multi-asset coverage
]

# Same parameters work across all providers
for provider <- providers do
  {:ok, df} = Quant.Explorer.history("BTC",
    provider: provider,
    interval: "1d",
    period: "1mo"
  )
end

4. Strategy Framework

Build and compose trading strategies:

defmodule MyStrategy do
  use Quant.Strategy

  def signals(df) do
    df
    |> Quant.Indicators.rsi(period: 14)
    |> Quant.Indicators.sma(period: 50)
    |> generate_signals()
  end

  defp generate_signals(df) do
    df
    |> DataFrame.mutate(
      signal: if rsi < 30 and close > sma_50, do: :buy,
              else if rsi > 70, do: :sell,
              else :hold
    )
  end
end

5. Backtesting Engine

Test strategies with comprehensive portfolio analysis:

strategy = MyStrategy.new()

results = Quant.Backtest.run(df, strategy,
  initial_capital: 10_000,
  commission: 0.001,
  slippage: 0.0005
)

# Analyze results
results.metrics
# => %{
#   total_return: 0.245,
#   sharpe_ratio: 1.82,
#   max_drawdown: -0.15,
#   win_rate: 0.58,
#   profit_factor: 2.1
# }

Technical Implementation

Architecture Decisions

1. Explorer/Polars Backend

Using Explorer (Elixir bindings for Polars) provides:

• Performance: Polars is one of the fastest DataFrame libraries
• Memory Efficiency: Columnar storage with lazy evaluation
• Parallel Processing: Built-in parallelization for operations
• Type Safety: Strong typing at the DataFrame level

# Lazy evaluation for efficient processing
df
|> DataFrame.lazy()
|> DataFrame.filter(volume > 1_000_000)
|> DataFrame.select(["symbol", "close", "volume"])
|> DataFrame.collect()

2. NX for Mathematical Operations

Leveraging NX (Numerical Elixir) for indicators:

defmodule Quant.Indicators.RSI do
  import Nx.Defn

  defn calculate_rsi(gains, losses, period) do
    avg_gain = Nx.mean(gains)
    avg_loss = Nx.mean(losses)

    rs = avg_gain / avg_loss
    100 - (100 / (1 + rs))
  end
end

3. Zero External HTTP Dependencies

Using Erlang's built-in :httpc to minimize dependencies:

defmodule Quant.HTTP do
  def get(url, headers \\ []) do
    :httpc.request(:get, {url, headers}, [], [])
    |> handle_response()
  end

  defp handle_response({:ok, {{_, 200, _}, _headers, body}}) do
    {:ok, body}
  end

  defp handle_response({:ok, {{_, status, _}, _, _}}) do
    {:error, {:http_error, status}}
  end
end

Cross-Provider Data Normalization

Each provider adapter implements a common behavior:

defmodule Quant.Provider.YahooFinance do
  @behaviour Quant.Provider

  @impl true
  def fetch(symbol, opts) do
    with {:ok, raw_data} <- fetch_raw(symbol, opts),
         {:ok, normalized} <- normalize(raw_data) do
      {:ok, to_dataframe(normalized)}
    end
  end

  defp normalize(raw_data) do
    # Transform provider-specific format to standard schema
    Enum.map(raw_data, fn row ->
      %{
        symbol: row["symbol"],
        timestamp: parse_timestamp(row["date"]),
        open: parse_float(row["open"]),
        high: parse_float(row["high"]),
        low: parse_float(row["low"]),
        close: parse_float(row["close"]),
        volume: parse_int(row["volume"]),
        adjusted_close: parse_float(row["adjclose"]),
        market_cap: nil,
        provider: "yahoo_finance",
        currency: "USD",
        timezone: "America/New_York"
      }
    end)
  end
end

Testing Strategy

Python Validation Framework

Each indicator is validated against Python implementations:

# test/indicators/rsi_test.exs
defmodule Quant.Indicators.RSITest do
  use ExUnit.Case
  @moduletag :python_validation

  test "RSI matches Python implementation" do
    # Load test data
    df = load_test_data("AAPL")

    # Calculate with Quant
    elixir_rsi = Quant.Indicators.rsi(df, period: 14)

    # Calculate with Python (pandas/numpy)
    python_rsi = run_python_script("calculate_rsi.py", df)

    # Compare results
    accuracy = calculate_accuracy(elixir_rsi, python_rsi)
    assert accuracy >= 0.9999  # 99.99% accuracy threshold
  end
end

Python validation script:

# scripts/calculate_rsi.py
import pandas as pd
import numpy as np

def calculate_rsi(df, period=14):
    delta = df['close'].diff()
    gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
    loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()

    rs = gain / loss
    rsi = 100 - (100 / (1 + rs))

    return rsi

if __name__ == '__main__':
    df = pd.read_csv('test_data.csv')
    rsi = calculate_rsi(df)
    print(rsi.to_json())

Validation Results

Indicator	Accuracy vs Python	Test Cases
RSI	100.00%	50
DEMA	99.96%	50
HMA	100.00%	50
KAMA	100.00%	50
TEMA	99.9988%	50
WMA	100.00%	50

Use Cases

1. Cross-Asset Portfolio Analysis

# Fetch data from multiple sources
{:ok, stocks} = Quant.Explorer.history("AAPL",
  provider: :yahoo_finance, interval: "1d", period: "1y")

{:ok, crypto} = Quant.Explorer.history("BTCUSDT",
  provider: :binance, interval: "1d", period: "1y")

# Combine and analyze
portfolio = DataFrame.concat_rows([stocks, crypto])

# Calculate correlation
correlation = portfolio
|> DataFrame.group_by("symbol")
|> DataFrame.pivot_wider("close", "symbol")
|> correlation_matrix()

2. Indicator Combination

# Combine multiple indicators for signals
df = df
|> Quant.Indicators.rsi(period: 14)
|> Quant.Indicators.sma(period: 20)
|> Quant.Indicators.sma(period: 50)
|> Quant.Indicators.tema(period: 30)
|> DataFrame.mutate(
  bullish_signal: rsi < 30 and sma_20 > sma_50 and close > tema_30,
  bearish_signal: rsi > 70 and sma_20 < sma_50
)

3. Parameter Optimization

# Test multiple parameter combinations
parameters = [
  rsi_period: 10..20,
  sma_short: 10..30//5,
  sma_long: 40..60//10
]

results = Quant.Optimize.grid_search(df, strategy, parameters,
  parallel: true,
  metric: :sharpe_ratio
)

# Find best parameters
best = Enum.max_by(results, & &1.sharpe_ratio)
# => %{rsi_period: 14, sma_short: 20, sma_long: 50, sharpe_ratio: 2.1}

4. Livebook Integration

Perfect for data science workflows:

# In Livebook
Mix.install([
  {:quant, github: "base59-dev/quant"},
  {:kino, "~> 0.12"}
])

# Interactive analysis
df = Quant.Explorer.history("AAPL",
  provider: :yahoo_finance, interval: "1d", period: "1y")

df
|> Quant.Indicators.rsi(period: 14)
|> Kino.DataTable.new()

Performance Characteristics

Benchmarks

Data Fetching (1 year daily data):
Yahoo Finance:    250ms
Binance:          180ms
Alpha Vantage:    320ms

Indicator Calculation (10,000 rows):
RSI:              5ms
DEMA:             8ms
HMA:              6ms
KAMA:             12ms
TEMA:             10ms
WMA:              4ms

Backtesting (1 year, 1 signal/week):
Portfolio Analysis: 45ms
Metrics Calculation: 15ms

Memory Efficiency

Thanks to Polars' columnar storage:

# 10 years of daily data (2,500 rows)
df = Quant.Explorer.history("AAPL", period: "10y")

# Memory usage
:erlang.memory(:total) |> div(1024 * 1024)
# => ~15MB for full dataset with all indicators

Configuration

Environment Variables

# Alpha Vantage API key
export ALPHA_VANTAGE_API_KEY="your_key_here"

# Twelve Data API key
export TWELVE_DATA_API_KEY="your_key_here"

Runtime Configuration

# config/runtime.exs
config :quant,
  providers: [
    alpha_vantage: [api_key: System.get_env("ALPHA_VANTAGE_API_KEY")],
    twelve_data: [api_key: System.get_env("TWELVE_DATA_API_KEY")]
  ],
  cache: [enabled: true, ttl: 3600],
  http: [timeout: 5000, retries: 3]

Inline API Keys

{:ok, df} = Quant.Explorer.history("AAPL",
  provider: :alpha_vantage,
  api_key: "your_key",
  interval: "1d",
  period: "1y"
)

Production Readiness

Type Safety

Full Dialyzer specifications:

@spec history(symbol :: String.t(), opts :: keyword()) ::
  {:ok, DataFrame.t()} | {:error, term()}

@spec rsi(DataFrame.t(), period: pos_integer()) :: DataFrame.t()

Error Handling

Comprehensive error handling:

case Quant.Explorer.history("INVALID", provider: :yahoo_finance) do
  {:ok, df} ->
    process_data(df)

  {:error, :not_found} ->
    Logger.warning("Symbol not found")

  {:error, :rate_limited} ->
    Logger.error("API rate limit exceeded")
    retry_with_backoff()

  {:error, reason} ->
    Logger.error("Unexpected error: #{inspect(reason)}")
end

Installation

Add to your mix.exs:

def deps do
  [
    {:quant, github: "base59-dev/quant"}
  ]
end

Requirements:

• Elixir 1.17+
• OTP 26+
• Explorer (automatically installed)

Future Roadmap

• More technical indicators (Bollinger Bands, MACD, Stochastic)
• Real-time data streaming
• Portfolio optimization algorithms
• Machine learning integration with Nx
• Options and derivatives support
• More data providers (IEX Cloud, Polygon.io)
• Built-in charting with VegaLite
• Paper trading mode

Tech Stack

• Language: Elixir 1.17+
• Data Processing: Explorer/Polars
• Math: NX (Numerical Elixir)
• HTTP: Erlang :httpc (zero deps)
• Testing: ExUnit + Python validation
• Type Checking: Dialyzer

License

CC BY-NC 4.0 - Non-commercial use only. Contact for commercial licensing.

---

Quant brings the power of quantitative analysis to the Elixir ecosystem, combining the performance of Polars with the elegance of Elixir's functional programming model. Whether you're building trading algorithms, analyzing market trends, or conducting research, Quant provides the tools you need.