5D Library › 做市商伽马敞口、零日到期期权与波动率收割动力学 · English

第四章 卖出波动率:胜率什么都没说,尾部说明一切

流行的说法

「每天卖一张 0DTE 铁鹰,85% 的时候赢,稳拿现金流。」这句话包含一个真实的数字和一个错误的推论。数字是胜率,它很容易被造出来:把卖出的行权价放得足够远,大多数日子就会收在两者之间。推论是高胜率意味着正的或稳定的期望。本章说明:胜率几乎不携带关于期望的任何信息;期望由期权相对其真实价值的价格决定;而一份真实的正向优势,其危险在于注码,而不在于符号。

这个流行说法还有一个悲观的镜像——「一年几次缺口就把权利金全吃光」——它同样是错的,而且错得很有启发性。

一个带缺口的模型

本章程序使用默顿跳跃扩散模型 (Merton 1976):年波动率 0.15 的扩散,加上每年三次的泊松跳跃,每次大小服从 Normal(−3%, 1.5%)。所以典型的缺口超过三个日标准差,就是交易圈所说的「一年几次 3-Sigma 缺口」。模型的总已实现波动率为 0.1609。

策略每天早上卖出一日期权,行权价放在 1.45 个扩散日标准差之外,使约 85% 的日子盈利。铁鹰另外买入 3.0 个标准差之外的保护翼。期权用三种方式定价:按 0.15 的布莱克-斯科尔斯,忽略跳跃;按模型下的真实期望支付,即零优势;按 0.17 的布莱克-斯科尔斯,内含指数期权文献所记录的那种方差溢价 (Carr and Wu 2009)。

推导

# Chapter 4. Selling one-day strangles and iron condors under jump diffusion
# (Merton). True model: daily log return = diffusion (sigma 0.15 a year) +
# Poisson jumps (3 a year, size Normal(mean -3 %, sd 1.5 %)): a 3-sigma-plus
# gap a few times a year. S = 100 each morning, r = 0. Strikes are set in
# DIFFUSIVE daily standard deviations (0.15 x sqrt(1/252) = 0.945 %): short
# put and call Z = 1.45 sd out of the money, so the strategy wins about 85 %
# of days; the condor adds long wings W = 3.0 sd out. Three ways the market
# might price the options:
#   "diffusion only"  Black-Scholes at 0.15: ignores the jumps entirely
#   "fair"            the true Merton expectation of each payoff: zero edge
#   "with premium"    Black-Scholes at 0.17: implied above realised (a
#   variance premium)
import math
import random

T = 1 / 252
SIG, LAM, MJ, SJ = 0.15, 3.0, -0.03, 0.015
Z, W = 1.45, 3.0

def Phi(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs(S, K, sig, T, call):
    sd = sig * math.sqrt(T)
    d1 = (math.log(S / K) + 0.5 * sd * sd) / sd
    d2 = d1 - sd
    if call:
        return S * Phi(d1) - K * Phi(d2)
    return K * Phi(-d2) - S * Phi(-d1)

def merton(S, K, T, call):
    k = math.exp(MJ + 0.5 * SJ * SJ) - 1
    tot = 0.0
    for n in range(8):
        w = math.exp(-LAM * T) * (LAM * T) ** n / math.factorial(n)
        sig_n = math.sqrt(SIG * SIG + n * SJ * SJ / T)
        S_n = S * math.exp(n * (MJ + 0.5 * SJ * SJ) - LAM * k * T)
        tot += w * bs(S_n, K, sig_n, T, call)
    return tot

def strikes():
    sd = SIG * math.sqrt(T)
    return (100 * math.exp(-Z * sd), 100 * math.exp(Z * sd),
            100 * math.exp(-W * sd), 100 * math.exp(W * sd))

def premium(kind, price_mode):
    sq = 0.17 if price_mode == "with premium" else SIG
    kp, kc, wp, wc = strikes()
    if price_mode == "fair":
        f = lambda K, c: merton(100.0, K, T, c)
    else:
        f = lambda K, c: bs(100.0, K, sq, T, c)
    prem = f(kp, False) + f(kc, True)
    if kind == "condor":
        prem -= f(wp, False) + f(wc, True)
    return prem, (kp, kc, wp, wc)

def payoff(kind, ks, ST):
    kp, kc, wp, wc = ks
    loss = max(kp - ST, 0) + max(ST - kc, 0)
    if kind == "condor":
        loss -= max(wp - ST, 0) + max(ST - wc, 0)
    return loss

def simulate(n_days, rng):
    out = []
    p_jump = 1 - math.exp(-LAM * T)
    comp = -LAM * (math.exp(MJ + 0.5 * SJ * SJ) - 1) * T
    for _ in range(n_days):
        x = -0.5 * SIG * SIG * T + comp + rng.gauss(0, SIG * math.sqrt(T))
        jumped = rng.random() < p_jump
        if jumped:
            x += rng.gauss(MJ, SJ)
        out.append((100 * math.exp(x), jumped))
    return out

def stats(pnl):
    n = len(pnl)
    m = sum(pnl) / n
    sd = math.sqrt(sum((p - m) ** 2 for p in pnl) / (n - 1))
    sk = sum((p - m) ** 3 for p in pnl) / n / sd ** 3
    return m, sd, sk

if __name__ == "__main__":
    rng = random.Random(56007)
    days = simulate(252 * 200, rng)
    print(
        "200 simulated years, one trade a day; P&L in points per 100 of"
        " underlying"
    )
    rows = []
    for kind in ("strangle", "condor"):
        for mode in ("diffusion only", "fair", "with premium"):
            prem, ks = premium(kind, mode)
            pnl = [prem - payoff(kind, ks, ST) for ST, _ in days]
            jloss = sum(-p for p, (_, j) in zip(pnl, days) if j and p < 0)
            jshare = jloss / (prem * len(days))
            m, sd, sk = stats(pnl)
            rows.append((kind, mode, prem, sum(p > 0 for p in pnl) / len(pnl),
                         m, sd, sk, min(pnl), m / sd * math.sqrt(252),
                         -min(pnl) / prem, jshare))
    print("kind      pricing         premium  win rate  mean P&L    sd")
    for r in rows:
        print(
            "{:<9} {:<15}{:7.4f}  {:7.3f}  {:+8.4f}  {:6.4f}".format(*r[:6])
        )
    print(
        "\nkind      pricing           skew    worst  Sharpe/yr "
        " worst/premium"
    )
    for r in rows:
        print("{:<9} {:<15} {:+6.2f} {:8.3f}  {:+8.2f}  {:9.0f}".format(
            r[0], r[1], *r[6:10]))
    print("\nkind      pricing         share of premium repaid on jump days")
    for r in rows:
        print("{:<9} {:<15}{:8.3f}".format(r[0], r[1], r[10]))
    nj = sum(j for _, j in days)
    print(
        "\njump days: {} of {} ({:.2f} a year)".format(
            nj, len(days), nj / 200
        )
    )
    print("realised volatility of the true model: {:.4f} a year".format(
        math.sqrt(SIG ** 2 + LAM * (MJ ** 2 + SJ ** 2))))
# 200 simulated years, one trade a day; P&L in points per 100 of underlying
# kind      pricing         premium  win rate  mean P&L    sd
# strangle  diffusion only  0.0620    0.862   -0.0186  0.3146
# strangle  fair            0.0822    0.867   +0.0015  0.3146
# strangle  with premium    0.1019    0.873   +0.0212  0.3146
# condor    diffusion only  0.0613    0.862   -0.0099  0.2286
# condor    fair            0.0725    0.865   +0.0013  0.2286
# condor    with premium    0.0992    0.872   +0.0280  0.2286
#
# kind      pricing           skew    worst  Sharpe/yr  worst/premium
# strangle  diffusion only   -7.80   -7.054     -0.94        114
# strangle  fair             -7.80   -7.034     +0.08         86
# strangle  with premium     -7.80   -7.015     +1.07         69
# condor    diffusion only   -4.03   -1.434     -0.69         23
# condor    fair             -4.03   -1.423     +0.09         20
# condor    with premium     -4.03   -1.397     +1.94         14
#
# kind      pricing         share of premium repaid on jump days
# strangle  diffusion only    0.311
# strangle  fair              0.232
# strangle  with premium      0.186
# condor    diffusion only    0.170
# condor    fair              0.142
# condor    with premium      0.101
#
# jump days: 551 of 50400 (2.75 a year)
# realised volatility of the true model: 0.1609 a year

先往下看胜率一栏:宽跨式为 0.862、0.867、0.873,铁鹰为 0.862、0.865、0.872。再看均值一栏:宽跨式为 −0.0186、+0.0015、+0.0212。胜率几乎不动,期望却变了号。胜率是行权价位置的属性;期望是期权价格的属性。

按只含扩散的价值定价的宽跨式,尽管 0.862 的日子盈利,平均仍在亏钱,因为价格漏掉了缺口:年化夏普比率 −0.94。按公允价值定价,它什么也赚不到(+0.08,是模拟噪声)。只有存在真实溢价时它才盈利,为 +1.07。

尾部各栏解释了「稳定现金流」的感觉从何而来。分布的偏度为 −7.80;最差的一天每 100 名义亏损 7.054 点,在公允价格下相当于 86 天的权利金,即使有溢价也相当于 69 天。

按 0.17 报价的宽跨式空头在 200 个模拟年里的日盈亏分布(对数纵轴):一堵小额盈利的墙,加一条细长的亏损尾巴。(同一模型的独立模拟,所以极端值与表中略有不同。)

注

末行铁鹰较高的夏普比率是一个假象。 它的保护翼按统一的 0.17 买入,远低于这个模型下保护翼的真实价值,所以在那一行里,铁鹰既卖出了昂贵的期权,又买入了便宜的保险。第五章对每一张期权一致定价,比较结果随之改变。

缺口并没有吃光全部权利金

最后一栏回答了悲观的版本。公允价格下,跳跃日的亏损偿还了全部所收权利金的 0.232;有溢价时为 0.186。其余部分——绝大部分——是在普通日子里偿还的:一次扩散性的波动直接穿过了卖出的行权价。在 200 个模拟年里共有 551 个跳跃日,每年 2.75 个。

所以两句口号都不对。卖波动率的人既不是只因缺口而获得报酬,也不是只因缺口而破产。要紧的是溢价是否超过全部亏损的真实价值;对一个确有溢价的卖方而言,要紧的是每笔交易押上多少。

一份交易记录能说明什么

如果优势是真的、而亏损罕见,一份短的记录通常会错过它们。第八段程序问:记录有多常误导人,朝哪个方向误导(「比索问题」)。

推导

# Chapter 4. What a short-volatility track record can show. Same true model
# and the same short strangle as p07 (strikes 1.45 diffusive sd out, quoted at
# 0.17 implied, so the strategy has a genuine positive edge). 4,000 simulated
# calendar years of 252 trades.
# Question: how often does a one-year or three-year record mislead, and in
# which direction? (A "peso problem": the rare loss is usually absent from a
# short sample.)
import math
import random

T = 1 / 252
SIG, LAM, MJ, SJ = 0.15, 3.0, -0.03, 0.015
Z, IV = 1.45, 0.17

def Phi(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs(S, K, sig, call):
    sd = sig * math.sqrt(T)
    d1 = (math.log(S / K) + 0.5 * sd * sd) / sd
    d2 = d1 - sd
    return S * Phi(d1) - K * Phi(d2) if call else K * Phi(-d2) - S * Phi(-d1)

SD = SIG * math.sqrt(T)
KP, KC = 100 * math.exp(-Z * SD), 100 * math.exp(Z * SD)
PREM = bs(100.0, KP, IV, False) + bs(100.0, KC, IV, True)
P_JUMP = 1 - math.exp(-LAM * T)
COMP = -LAM * (math.exp(MJ + 0.5 * SJ * SJ) - 1) * T

def one_year(rng):
    pnl, jumps = [], 0
    for _ in range(252):
        x = -0.5 * SIG * SIG * T + COMP + rng.gauss(0, SIG * math.sqrt(T))
        if rng.random() < P_JUMP:
            x += rng.gauss(MJ, SJ)
            jumps += 1
        ST = 100 * math.exp(x)
        pnl.append(PREM - max(KP - ST, 0) - max(ST - KC, 0))
    return pnl, jumps

def sharpe(p):
    m = sum(p) / len(p)
    sd = math.sqrt(sum((x - m) ** 2 for x in p) / (len(p) - 1))
    return m / sd * math.sqrt(252)

if __name__ == "__main__":
    rng = random.Random(56008)
    years = [one_year(rng) for _ in range(4000)]
    allp = [x for p, _ in years for x in p]
    true_m = sum(allp) / len(allp)
    print("premium per trade {:.4f}; long-run mean P&L per trade {:+.4f};"
          .format(PREM, true_m))
    print("long-run Sharpe {:+.2f}".format(sharpe(allp)))
    tot = sorted(sum(p) for p, _ in years)
    print("\nA. One-year outcomes (sum of 252 trades, points per 100)")
    print(
        "   mean {:+.2f}   median {:+.2f}   5th pct {:+.2f}   worst {:+.2f}"
        .format(
            sum(tot) / len(tot),
            tot[len(tot) // 2],
            tot[len(tot) // 20],
            tot[0],
        )
    )
    print(
        "   share of losing years: {:.3f}".format(
            sum(t < 0 for t in tot) / len(tot)
        )
    )
    nj = [j for _, j in years]
    print("   share of years with no jump: {:.3f}  (Poisson: {:.3f})".format(
        sum(j == 0 for j in nj) / len(nj), math.exp(-LAM)))

    print(
        "\nB. What a record shows, by the number of jumps it happened to"
        " contain"
    )
    print(
        "   jumps in year  share of years  mean 1-yr Sharpe  mean P&L/trade"
    )
    print("                                                    vs truth")
    for k in range(0, 6):
        sel = [p for p, j in years if j == k]
        if not sel:
            continue
        ms = sum(sum(p) / 252 for p in sel) / len(sel)
        print(
            "   {:>8}      {:9.3f}      {:+10.2f}        x {:5.2f}".format(
                k,
                len(sel) / len(years),
                sum(sharpe(p) for p in sel) / len(sel),
                ms / true_m,
            )
        )

    print("\nC. Three-year records (non-overlapping blocks)")
    blocks = [
        sum((years[i + d][0] for d in range(3)), [])
        for i in range(0, 3999, 3)
    ]
    sh = sorted(sharpe(b) for b in blocks)
    print(
        "   median 3-yr Sharpe {:+.2f}; share above 2.0: {:.3f}; share below"
        " 0: {:.3f}".format(
            sh[len(sh) // 2],
            sum(s > 2.0 for s in sh) / len(sh),
            sum(s < 0 for s in sh) / len(sh),
        )
    )
# premium per trade 0.1019; long-run mean P&L per trade +0.0205;
# long-run Sharpe +1.04
#
# A. One-year outcomes (sum of 252 trades, points per 100)
#    mean +5.17   median +5.58   5th pct -3.65   worst -19.16
#    share of losing years: 0.152
#    share of years with no jump: 0.051  (Poisson: 0.050)
#
# B. What a record shows, by the number of jumps it happened to contain
#    jumps in year  share of years  mean 1-yr Sharpe  mean P&L/trade
#                                                     vs truth
#           0          0.051           +3.32        x  1.90
#           1          0.157           +2.43        x  1.61
#           2          0.223           +1.85        x  1.33
#           3          0.217           +1.28        x  1.00
#           4          0.167           +0.86        x  0.66
#           5          0.105           +0.46        x  0.32
#
# C. Three-year records (non-overlapping blocks)
#    median 3-yr Sharpe +1.09; share above 2.0: 0.131; share below 0: 0.043

这个策略的长期夏普比率为 +1.04。但恰好没有跳跃的一年——占 0.051,与泊松公式的预测一致——平均显示 +3.32 的夏普比率,把真实的平均盈亏高估到 1.90 倍。有五次跳跃的一年显示 +0.46,把它低估到 0.32 倍。即使是三年的记录也很分散:0.131 的三年记录夏普比率超过 2.0,0.043 低于零。按这份证据,一个第一年做得很好的交易者,最可能只是一个那年缺口很少的交易者。

证据

关于期权收益已知的情况。 Coval 与 Shumway 发现,指数期权的收益低得无法只用其市场风险解释——买入它们平均亏钱——这与承担波动率或崩盘风险获得定价溢价相一致 (Coval and Shumway 2001)。Carr 与 Wu 直接测量了方差风险溢价,发现标普 500 指数的方差风险溢价显著为负:隐含方差平均高于随后的已实现方差 (Carr and Wu 2009)。Bondarenko 论证了指数认沽的高价格难以用标准模型解释 (Bondarenko 2014)。这些结果支持把「有溢价」那一行当作指数期权的相关情形——在长样本上。它们并没有说 0DTE 期权的溢价也一样,也没有说溢价逐年稳定。

为一个偏斜的赌注定注码

偏度 −7.80 的真实优势是一个注码问题。第九段程序使用财富对数的增长率——凯利注码背后的准则 (Kelly 1956)——杠杆 LL 定义为每天卖出的名义本金除以账户权益。

推导

# Chapter 4. Sizing a positive-edge but negatively skewed bet. Same true model
# and the same short strangle quoted at 0.17 as p07/p08. Notional leverage L =
# underlying notional sold per day / account equity, so the account's daily
# return is L x P&L / 100. Growth rate g(L) = mean log(1 + L x P&L / 100) over
# 200 simulated years; a day with 1 + L x P&L / 100 <= 0 wipes the account
# out. Then: probability of a 50 % drawdown within five years, on 2,000
# simulated five-year paths, for several L.
import math
import random

T = 1 / 252
SIG, LAM, MJ, SJ = 0.15, 3.0, -0.03, 0.015
Z, IV = 1.45, 0.17

def Phi(x):
    return 0.5 * (1.0 + math.erf(x / math.sqrt(2.0)))

def bs(S, K, sig, call):
    sd = sig * math.sqrt(T)
    d1 = (math.log(S / K) + 0.5 * sd * sd) / sd
    d2 = d1 - sd
    return S * Phi(d1) - K * Phi(d2) if call else K * Phi(-d2) - S * Phi(-d1)

SD = SIG * math.sqrt(T)
KP, KC = 100 * math.exp(-Z * SD), 100 * math.exp(Z * SD)
PREM = bs(100.0, KP, IV, False) + bs(100.0, KC, IV, True)
P_JUMP = 1 - math.exp(-LAM * T)
COMP = -LAM * (math.exp(MJ + 0.5 * SJ * SJ) - 1) * T

def day(rng):
    x = -0.5 * SIG * SIG * T + COMP + rng.gauss(0, SIG * math.sqrt(T))
    if rng.random() < P_JUMP:
        x += rng.gauss(MJ, SJ)
    ST = 100 * math.exp(x)
    return PREM - max(KP - ST, 0) - max(ST - KC, 0)

def growth(L, sample):
    tot = 0.0
    for p in sample:
        y = 1 + L * p / 100
        if y <= 0:
            return float("-inf")
        tot += math.log(y)
    return tot / len(sample) * 252

if __name__ == "__main__":
    rng = random.Random(56009)
    sample = [day(rng) for _ in range(252 * 200)]
    worst = min(sample)
    print("worst simulated day {:.3f} points per 100:".format(worst))
    print("any L above {:.1f} is wiped out on it".format(-100 / worst))
    best_L, best_g = 0.0, 0.0
    for i in range(1, 400):
        L = i * 0.05
        g = growth(L, sample)
        if g > best_g:
            best_L, best_g = L, g
    print(
        "growth-optimal (Kelly) leverage L* = {:.2f}; growth {:+.3f} log"
        " units a year".format(best_L, best_g)
    )
    print(
        "\n  L        growth/yr   P(50 % drawdown in 5 yrs)   P(wiped out in"
        " 5 yrs)"
    )
    for L in (
        0.25 * best_L,
        0.5 * best_L,
        10.0,
        best_L,
        1.5 * best_L,
        2 * best_L,
    ):
        g = growth(L, sample)
        dd = wipe = 0
        for _ in range(2000):
            eq, peak, hit = 1.0, 1.0, False
            for _ in range(252 * 5):
                eq *= max(0.0, 1 + L * day(rng) / 100)
                if eq <= 0:
                    wipe += 1
                    hit = True
                    break
                peak = max(peak, eq)
                if eq < 0.5 * peak:
                    hit = True
            dd += hit
        print(
            "  {:5.2f}    {:>8}         {:7.3f}                    {:7.3f}"
            .format(
                L,
                "-inf" if g == float("-inf") else "{:+.3f}".format(g),
                dd / 2000,
                wipe / 2000,
            )
        )

    print(
        "\nKelly estimated from a 10-year record instead (25 independent"
        " records)"
    )
    ests = []
    for _ in range(25):
        rec = [day(rng) for _ in range(2520)]
        bl, bg = 0.0, 0.0
        for i in range(1, 600):
            g = growth(i * 0.05, rec)
            if g > bg:
                bl, bg = i * 0.05, g
        ests.append(bl)
    ests.sort()
    print("  estimated L*: min {:.2f}, median {:.2f}, max {:.2f}".format(
        ests[0], ests[12], ests[-1]))
    print(
        "  records whose estimated L* would be wiped out by the 200-year"
        " worst"
    )
    print("  day: {} of 25".format(sum(L > -100 / worst for L in ests)))
# worst simulated day -7.352 points per 100:
# any L above 13.6 is wiped out on it
# growth-optimal (Kelly) leverage L* = 12.40; growth +0.406 log units a year
#
#   L        growth/yr   P(50 % drawdown in 5 yrs)   P(wiped out in 5 yrs)
#    3.10      +0.153           0.011                      0.000
#    6.20      +0.278           0.301                      0.000
#   10.00      +0.381           0.828                      0.000
#   12.40      +0.406           0.959                      0.001
#   18.60        -inf           0.998                      0.135
#   24.80        -inf           1.000                      0.635
#
# Kelly estimated from a 10-year record instead (25 independent records)
#   estimated L*: min 5.40, median 13.85, max 22.90
#   records whose estimated L* would be wiped out by the 200-year worst
#   day: 13 of 25

有三个结果很突出。第一,增长最优杠杆为 12.40,而任何高于 13.6 的杠杆都会被模拟中最差的一天清零:最优点就挨着悬崖,而悬崖的位置由一个观测值决定——样本中最差的那一天。第二,即便在最优点,五年内出现 50% 回撤的概率也有 0.959;最优点的一半为 0.301,四分之一为 0.011。第三,也是最重要的,最优点必须被估计。从 25 份相互独立的十年记录估出的最优点在 5.40 到 22.90 之间,其中 25 份里有 13 份的估计值落在由 200 年最差一天确定的悬崖之外。

同一策略的对数财富增长率随杠杆的变化(独立模拟样本)。曲线在虚线前方不远处达到峰值;虚线是样本中最差一天使账户清零的杠杆,越过它增长率为负无穷。

所以卖波动率的脆弱性不在于期望为负。在这个模型里期望是正的。脆弱性在于:决定安全规模的那个量——最大亏损的深度——恰恰是一份记录最无法测量的量。

小结

卖波动率策略的胜率由行权价的位置决定,对其期望几乎什么都没说;期望由期权相对真实价值的价格决定:在 86-87% 的胜率下,同一张宽跨式仅因价格不同而有负、零或正的期望。缺口并没有吃光全部权利金——大部分在普通日子里偿还——但它们主宰尾部,一天就可能抵掉 69 到 114 天的权利金。对指数期权而言,在长样本上正向优势是真实的,但短记录会在两个方向上误报它,而增长最优的规模挨着一道悬崖,悬崖的位置是记录无法可靠测量的。

参考文献

Bondarenko, Oleg. 2014. “Why Are Put Options so Expensive?” Quarterly Journal of Finance 4 (3): 1450015.
Carr, Peter, and Liuren Wu. 2009. “Variance Risk Premiums.” The Review of Financial Studies 22 (3): 1311–41.
Coval, Joshua D., and Tyler Shumway. 2001. “Expected Option Returns.” The Journal of Finance 56 (3): 983–1009.
Kelly, Jr., John L. 1956. “A New Interpretation of Information Rate.” Bell System Technical Journal 35 (4): 917–26. https://doi.org/10.1002/j.1538-7305.1956.tb03809.x.
Merton, Robert C. 1976. “Option Pricing When Underlying Stock Returns Are Discontinuous.” Journal of Financial Economics 3 (1–2): 125–44. https://doi.org/10.1016/0304-405X(76)90022-2.

Fan, Y. (2026). Dealer Gamma Exposure, Zero-Day Options and Volatility Harvesting Dynamics: Delta-Hedging Feedback Loops, Strike Pinning, Iron Condor Tail Ruin and Variance Swap Replication [做市商伽马敞口、零日到期期权与波动率收割动力学] (Version 1.0.0). 5D Library. https://doi.org/10.5281/zenodo.24090160 · Licensed under Creative Commons Attribution-NonCommercial-NoDerivatives 4.0 International (CC BY-NC-ND 4.0).