id stringlengths 18 18 | domain stringclasses 2
values | is_edge_case bool 2
classes | prompt stringlengths 71 231 | code_solution stringlengths 128 587 | expected_payload dict | total_reward int64 1 1 |
|---|---|---|---|---|---|---|
finquant-eval-0001 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$169.0, Strike=$248.0, T=0.96y, Rate=5.1499999999999995%, Vol=29.18% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 169.0, 248.0, 0.96, 0.0515, 0.0271, 0.2918
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 2.7755,
"clean_count": null,
"delta": 0.1287,
"status": null
} | 1 |
finquant-eval-0002 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.30', 'N/A', '$100.68', 'N/A', '$99.31', ' 97.8820 USD ', ' 99.6445 USD ', '$99.29', ' 98.7181 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.30', 'N/A', '$100.68', 'N/A', '$99.31', ' 97.8820 USD ', ' 99.6445 USD ', '$99.29', ' 98.7181 USD ', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: clean... | {
"ann_volatility": 0.199,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0003 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$241.0, Strike=$187.0, T=-0.5 | import json
if -0.5 <= 0:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Time to maturity T cannot be negative."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0004 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$101.34', '$99.48', '$98.25', '$97.98', 'N/A', ' 96.4658 USD ', ' 96.3616 USD ', ' 95.8603 USD ', ' 97.5038 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$101.34', '$99.48', '$98.25', '$97.98', 'N/A', ' 96.4658 USD ', ' 96.3616 USD ', ' 95.8603 USD ', ' 97.5038 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
t... | {
"ann_volatility": 0.2046,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0005 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', 'N/A', 'N/A', ' 94.6382 USD ', '$93.33', 'N/A', '$94.86', 'N/A', '$96.91', ' 95.1528 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', 'N/A', 'N/A', ' 94.6382 USD ', '$93.33', 'N/A', '$94.86', 'N/A', '$96.91', ' 95.1528 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(float... | {
"ann_volatility": 0.4889,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0006 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', 'N/A', '$100.92', 'N/A', 'N/A', '$102.06', 'N/A', '$104.63', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', 'N/A', '$100.92', 'N/A', 'N/A', '$102.06', 'N/A', '$104.63', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(float(clean_str))
... | {
"ann_volatility": 0.1355,
"call_price": null,
"clean_count": 4,
"delta": null,
"status": null
} | 1 |
finquant-eval-0007 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$248.0, Strike=$286.0, T=0.88y, Rate=2.39%, Vol=16.31% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 248.0, 286.0, 0.88, 0.0239, 0.0019, 0.1631
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 4.79,
"clean_count": null,
"delta": 0.23270000000000002,
"status": null
} | 1 |
finquant-eval-0008 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', 'N/A', 'N/A', '$100.03', ' 99.5225 USD ', ' 100.1788 USD ', ' 102.0313 USD ', ' 100.3338 USD ', 'N/A', ' 102.4909 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', 'N/A', 'N/A', '$100.03', ' 99.5225 USD ', ' 100.1788 USD ', ' 102.0313 USD ', ' 100.3338 USD ', 'N/A', ' 102.4909 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.22870000000000001,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0009 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.98', 'N/A', ' 101.4489 USD ', 'N/A', '$99.83', '$100.54', ' 100.8266 USD ', '$101.95', ' 101.7899 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.98', 'N/A', ' 101.4489 USD ', 'N/A', '$99.83', '$100.54', ' 100.8266 USD ', '$101.95', ' 101.7899 USD ', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cl... | {
"ann_volatility": 0.16010000000000002,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0010 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$162.0, Strike=$186.0, T=1.01y, Rate=2.23%, Vol=41.589999999999996% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 162.0, 186.0, 1.01, 0.0223, 0.0292, 0.4159
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 17.4363,
"clean_count": null,
"delta": 0.43210000000000004,
"status": null
} | 1 |
finquant-eval-0011 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$258.0, Strike=$223.0, T=1.49y, Rate=5.220000000000001%, Vol=27.389999999999997% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 258.0, 223.0, 1.49, 0.0522, 0.0153, 0.2739
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 58.6287,
"clean_count": null,
"delta": 0.7611,
"status": null
} | 1 |
finquant-eval-0012 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$99.0, Strike=$89.0, T=0.26y, Rate=1.6%, Vol=41.83% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 99.0, 89.0, 0.26, 0.016, 0.0161, 0.4183
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T) ... | {
"ann_volatility": null,
"call_price": 13.8935,
"clean_count": null,
"delta": 0.7246,
"status": null
} | 1 |
finquant-eval-0013 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$159.0, Strike=$180.0, T=1.31y, Rate=3.0%, Vol=34.88% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 159.0, 180.0, 1.31, 0.03, 0.0032, 0.3488
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T)... | {
"ann_volatility": null,
"call_price": 19.4907,
"clean_count": null,
"delta": 0.4887,
"status": null
} | 1 |
finquant-eval-0014 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$248.0, Strike=$114.0, T=0.63y, Rate=5.609999999999999%, Vol=37.63% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 248.0, 114.0, 0.63, 0.0561, 0.0185, 0.3763
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 135.1398,
"clean_count": null,
"delta": 0.9861000000000001,
"status": null
} | 1 |
finquant-eval-0015 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 101.8271 USD ', '$101.93', '$102.40', ' 100.4278 USD ', '$99.33', '$97.50', '$99.29', '$98.29', '$97.59', ' 97.1192 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 101.8271 USD ', '$101.93', '$102.40', ' 100.4278 USD ', '$99.33', '$97.50', '$99.29', '$98.29', '$97.59', ' 97.1192 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.21280000000000002,
"call_price": null,
"clean_count": 11,
"delta": null,
"status": null
} | 1 |
finquant-eval-0016 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.08', ' 102.7718 USD ', '$102.84', ' 103.4254 USD ', '$101.74', 'N/A', '$100.42', 'N/A', '$99.61', ' 101.4071 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.08', ' 102.7718 USD ', '$102.84', ' 103.4254 USD ', '$101.74', 'N/A', '$100.42', 'N/A', '$99.61', ' 101.4071 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
tr... | {
"ann_volatility": 0.21,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0017 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$175.0, Strike=$276.0, T=1.45y, Rate=4.72%, Vol=17.080000000000002% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 175.0, 276.0, 1.45, 0.0472, 0.0087, 0.1708
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 0.42610000000000003,
"clean_count": null,
"delta": 0.0324,
"status": null
} | 1 |
finquant-eval-0018 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.45', 'N/A', 'N/A', 'N/A', ' 95.5708 USD ', ' 95.1785 USD ', 'N/A', ' 96.8733 USD ', 'N/A', ' 98.2345 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.45', 'N/A', 'N/A', 'N/A', ' 95.5708 USD ', ' 95.1785 USD ', 'N/A', ' 96.8733 USD ', 'N/A', ' 98.2345 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleane... | {
"ann_volatility": 0.3614,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0019 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$109.0, Strike=$101.0, T=1.0y, Rate=1.13%, Vol=18.33% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 109.0, 101.0, 1.0, 0.0113, 0.0118, 0.1833
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 12.1431,
"clean_count": null,
"delta": 0.685,
"status": null
} | 1 |
finquant-eval-0020 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$226.0, Strike=$234.0, T=0.72y, Rate=3.8%, Vol=28.95% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 226.0, 234.0, 0.72, 0.038, 0.0173, 0.2895
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 19.8687,
"clean_count": null,
"delta": 0.5103,
"status": null
} | 1 |
finquant-eval-0021 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$102.0, Strike=$84.0, T=1.57y, Rate=4.89%, Vol=17.76% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 102.0, 84.0, 1.57, 0.0489, 0.0032, 0.1776
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 24.8127,
"clean_count": null,
"delta": 0.8997,
"status": null
} | 1 |
finquant-eval-0022 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$263.0, Strike=$209.0, T=1.04y, Rate=1.78%, Vol=20.36% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 263.0, 209.0, 1.04, 0.0178, 0.0233, 0.2036
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 54.9308,
"clean_count": null,
"delta": 0.8605,
"status": null
} | 1 |
finquant-eval-0023 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$103.0, Strike=$86.0, T=0.78y, Rate=4.53%, Vol=23.75% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 103.0, 86.0, 0.78, 0.0453, 0.0139, 0.2375
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 20.5489,
"clean_count": null,
"delta": 0.851,
"status": null
} | 1 |
finquant-eval-0024 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$228.0, Strike=$90.0, T=0.75y, Rate=3.91%, Vol=18.82% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 228.0, 90.0, 0.75, 0.0391, 0.025, 0.1882
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T)... | {
"ann_volatility": null,
"call_price": 136.3658,
"clean_count": null,
"delta": 0.9814,
"status": null
} | 1 |
finquant-eval-0025 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.45', '$101.13', 'N/A', 'N/A', ' 97.3100 USD ', 'N/A', '$96.76', 'N/A', '$97.73', ' 98.5971 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.45', '$101.13', 'N/A', 'N/A', ' 97.3100 USD ', 'N/A', '$96.76', 'N/A', '$97.73', ' 98.5971 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(... | {
"ann_volatility": 0.3075,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0026 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$186.0, Strike=$216.0, T=0.88y, Rate=2.13%, Vol=24.13% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 186.0, 216.0, 0.88, 0.0213, 0.0101, 0.2413
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 7.3153,
"clean_count": null,
"delta": 0.3045,
"status": null
} | 1 |
finquant-eval-0027 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', 'N/A', 'N/A', '$104.39', 'N/A', 'N/A', ' 108.6799 USD ', '$107.11', ' 105.2157 USD ', ' 104.6217 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', 'N/A', 'N/A', '$104.39', 'N/A', 'N/A', ' 108.6799 USD ', '$107.11', ' 105.2157 USD ', ' 104.6217 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.... | {
"ann_volatility": 0.4777,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0028 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$67.0, Strike=$237.0, T=1.59y, Rate=2.77%, Vol=24.64% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 67.0, 237.0, 1.59, 0.0277, 0.0114, 0.2464
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 0.00030000000000000003,
"clean_count": null,
"delta": 0.0001,
"status": null
} | 1 |
finquant-eval-0029 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$100.38', ' 100.1223 USD ', '$98.39', '$99.21', ' 97.7795 USD ', ' 96.6881 USD ', '$96.65', ' 96.4628 USD ', '$94.90', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$100.38', ' 100.1223 USD ', '$98.39', '$99.21', ' 97.7795 USD ', ' 96.6881 USD ', '$96.65', ' 96.4628 USD ', '$94.90', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.1482,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0030 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 99.2897 USD ', ' 99.4812 USD ', ' 97.6485 USD ', '$96.69', '$95.74', '$94.49', ' 93.1218 USD ', ' 93.7085 USD ', '$95.33'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 99.2897 USD ', ' 99.4812 USD ', ' 97.6485 USD ', '$96.69', '$95.74', '$94.49', ' 93.1218 USD ', ' 93.7085 USD ', '$95.33']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.1827,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0031 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$221.0, Strike=$106.0, T=1.64y, Rate=1.7399999999999998%, Vol=17.27% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 221.0, 106.0, 1.64, 0.0174, 0.0225, 0.1727
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 109.9802,
"clean_count": null,
"delta": 0.9634,
"status": null
} | 1 |
finquant-eval-0032 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$196.0, Strike=$229.0, T=1.17y, Rate=2.97%, Vol=16.09% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 196.0, 229.0, 1.17, 0.0297, 0.0044, 0.1609
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 4.9467,
"clean_count": null,
"delta": 0.2607,
"status": null
} | 1 |
finquant-eval-0033 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 98.9095 USD ', 'N/A', ' 98.7857 USD ', ' 100.2294 USD ', 'N/A', '$100.93', 'N/A', ' 99.8832 USD ', '$99.00', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 98.9095 USD ', 'N/A', ' 98.7857 USD ', ' 100.2294 USD ', 'N/A', '$100.93', 'N/A', ' 99.8832 USD ', '$99.00', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: c... | {
"ann_volatility": 0.16670000000000001,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0034 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$285.0, Strike=$150.0, T=1.38y, Rate=4.390000000000001%, Vol=27.13% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 285.0, 150.0, 1.38, 0.0439, 0.0074, 0.2713
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 141.255,
"clean_count": null,
"delta": 0.9801000000000001,
"status": null
} | 1 |
finquant-eval-0035 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$239.0, Strike=$223.0, T=1.53y, Rate=1.44%, Vol=40.07% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 239.0, 223.0, 1.53, 0.0144, 0.0036, 0.4007
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 55.0349,
"clean_count": null,
"delta": 0.6595000000000001,
"status": null
} | 1 |
finquant-eval-0036 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$225.0, Strike=$290.0, T=-0.5 | import json
if -0.5 <= 0:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Time to maturity T cannot be negative."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0037 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$266.0, Strike=$101.0, T=1.4y, Rate=4.859999999999999%, Vol=14.14% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 266.0, 101.0, 1.4, 0.0486, 0.0097, 0.1414
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 168.0556,
"clean_count": null,
"delta": 0.9865,
"status": null
} | 1 |
finquant-eval-0038 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.3370 USD ', '$101.09', ' 101.4961 USD ', 'N/A', ' 100.5989 USD ', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.3370 USD ', '$101.09', ' 101.4961 USD ', 'N/A', ' 100.5989 USD ', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.appe... | {
"ann_volatility": 0.1134,
"call_price": null,
"clean_count": 5,
"delta": null,
"status": null
} | 1 |
finquant-eval-0039 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.95', ' 99.7073 USD ', '$100.26', '$100.69', '$99.02', 'N/A', 'N/A', '$101.24', '$102.04', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.95', ' 99.7073 USD ', '$100.26', '$100.69', '$99.02', 'N/A', 'N/A', '$101.24', '$102.04', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(fl... | {
"ann_volatility": 0.1867,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0040 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$262.0, Strike=$215.0, T=0.41y, Rate=4.75%, Vol=36.6% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 262.0, 215.0, 0.41, 0.0475, 0.0144, 0.366
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 55.0815,
"clean_count": null,
"delta": 0.8408,
"status": null
} | 1 |
finquant-eval-0041 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.3993 USD ', ' 99.7204 USD ', ' 98.3354 USD ', 'N/A', 'N/A', ' 100.4267 USD ', 'N/A', ' 101.1361 USD ', '$100.17', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.3993 USD ', ' 99.7204 USD ', ' 98.3354 USD ', 'N/A', 'N/A', ' 100.4267 USD ', 'N/A', ' 101.1361 USD ', '$100.17', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.20600000000000002,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0042 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.3143 USD ', '$97.50', '$98.86', ' 98.3074 USD ', '$96.54', ' 96.0393 USD ', ' 97.0706 USD ', 'N/A', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.3143 USD ', '$97.50', '$98.86', ' 98.3074 USD ', '$96.54', ' 96.0393 USD ', ' 97.0706 USD ', 'N/A', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: ... | {
"ann_volatility": 0.20020000000000002,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0043 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$100.59', ' 99.5464 USD ', 'N/A', 'N/A', ' 99.2291 USD ', '$98.52', ' 96.6434 USD ', 'N/A', '$95.86', ' 97.2644 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$100.59', ' 99.5464 USD ', 'N/A', 'N/A', ' 99.2291 USD ', '$98.52', ' 96.6434 USD ', 'N/A', '$95.86', ' 97.2644 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try:... | {
"ann_volatility": 0.1766,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0044 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$200.0, Strike=$114.0, T=-0.5 | import json
if -0.5 <= 0:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Time to maturity T cannot be negative."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0045 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', 'N/A', '$100.86', '$100.55', 'N/A', ' 100.2482 USD ', ' 100.0328 USD ', ' 100.5543 USD ', ' 100.5790 USD ', ' 100.8689 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', 'N/A', '$100.86', '$100.55', 'N/A', ' 100.2482 USD ', ' 100.0328 USD ', ' 100.5543 USD ', ' 100.5790 USD ', ' 100.8689 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':... | {
"ann_volatility": 0.0713,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0046 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.1814 USD ', '$101.29', 'N/A', '$101.59', ' 102.7333 USD ', ' 102.2148 USD ', ' 100.3965 USD ', ' 101.6114 USD ', '$103.39', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.1814 USD ', '$101.29', 'N/A', '$101.59', ' 102.7333 USD ', ' 102.2148 USD ', ' 100.3965 USD ', ' 101.6114 USD ', '$103.39', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != ... | {
"ann_volatility": 0.18130000000000002,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0047 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$254.0, Strike=$257.0, T=0.72y, Rate=5.07%, Vol=27.93% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 254.0, 257.0, 0.72, 0.0507, 0.0034, 0.2793
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 26.5364,
"clean_count": null,
"delta": 0.5828,
"status": null
} | 1 |
finquant-eval-0048 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 97.3610 USD ', ' 98.1920 USD ', 'N/A', '$98.38', '$97.07', '$98.63', '$100.46', ' 102.1938 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 97.3610 USD ', ' 98.1920 USD ', 'N/A', '$98.38', '$97.07', '$98.63', '$100.46', ' 102.1938 USD ', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: clean... | {
"ann_volatility": 0.2741,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0049 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$90.0, Strike=$299.0, T=1.41y, Rate=5.25%, Vol=16.71% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 90.0, 299.0, 1.41, 0.0525, 0.0288, 0.1671
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 0,
"clean_count": null,
"delta": 0,
"status": null
} | 1 |
finquant-eval-0050 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 101.4433 USD ', ' 101.6411 USD ', ' 100.7531 USD ', ' 100.6051 USD ', '$101.96', ' 103.5021 USD ', ' 104.2657 USD ', '$103.16', 'N/A', '$103.06'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 101.4433 USD ', ' 101.6411 USD ', ' 100.7531 USD ', ' 100.6051 USD ', '$101.96', ' 103.5021 USD ', ' 104.2657 USD ', '$103.16', 'N/A', '$103.06']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and cl... | {
"ann_volatility": 0.15480000000000002,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0051 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.32', 'N/A', ' 96.6577 USD ', ' 95.4843 USD ', ' 97.3215 USD ', 'N/A', '$100.69', '$99.31', ' 100.4707 USD ', '$102.28'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.32', 'N/A', ' 96.6577 USD ', ' 95.4843 USD ', ' 97.3215 USD ', 'N/A', '$100.69', '$99.31', ' 100.4707 USD ', '$102.28']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.3306,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0052 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0053 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0054 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0055 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.3927 USD ', 'N/A', '$97.46', '$96.02', ' 97.4737 USD ', ' 95.6626 USD ', '$95.39', '$96.02', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.3927 USD ', 'N/A', '$97.46', '$96.02', ' 97.4737 USD ', ' 95.6626 USD ', '$95.39', '$96.02', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleane... | {
"ann_volatility": 0.2518,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0056 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0057 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.23', 'N/A', 'N/A', 'N/A', ' 100.9888 USD ', '$102.26', 'N/A', 'N/A', ' 104.7257 USD ', ' 105.9110 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.23', 'N/A', 'N/A', 'N/A', ' 100.9888 USD ', '$102.26', 'N/A', 'N/A', ' 104.7257 USD ', ' 105.9110 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.... | {
"ann_volatility": 0.1477,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0058 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$182.0, Strike=$279.0, T=0.3y, Rate=3.45%, Vol=15.4% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 182.0, 279.0, 0.3, 0.0345, 0.0207, 0.154
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T)... | {
"ann_volatility": null,
"call_price": 0,
"clean_count": null,
"delta": 0,
"status": null
} | 1 |
finquant-eval-0059 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$71.0, Strike=$114.0, T=0.44y, Rate=2.12%, Vol=39.09% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 71.0, 114.0, 0.44, 0.0212, 0.0131, 0.3909
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 0.3183,
"clean_count": null,
"delta": 0.0459,
"status": null
} | 1 |
finquant-eval-0060 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 101.7907 USD ', 'N/A', '$104.81', 'N/A', '$103.10', '$101.41', ' 99.5288 USD ', 'N/A', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 101.7907 USD ', 'N/A', '$104.81', 'N/A', '$103.10', '$101.41', ' 99.5288 USD ', 'N/A', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(f... | {
"ann_volatility": 0.3602,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0061 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.5177 USD ', ' 99.0702 USD ', '$97.56', 'N/A', ' 95.8283 USD ', ' 95.4290 USD ', 'N/A', ' 94.8931 USD ', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.5177 USD ', ' 99.0702 USD ', '$97.56', 'N/A', ' 95.8283 USD ', ' 95.4290 USD ', 'N/A', ' 94.8931 USD ', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
t... | {
"ann_volatility": 0.0983,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0062 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$79.0, Strike=$131.0, T=1.71y, Rate=5.949999999999999%, Vol=39.73% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 79.0, 131.0, 1.71, 0.0595, 0.0168, 0.3973
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 5.5025,
"clean_count": null,
"delta": 0.2752,
"status": null
} | 1 |
finquant-eval-0063 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$169.0, Strike=$129.0, T=-0.5 | import json
if -0.5 <= 0:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Time to maturity T cannot be negative."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0064 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.72', 'N/A', '$96.68', ' 94.9129 USD ', 'N/A', 'N/A', 'N/A', 'N/A', '$95.23', ' 94.2556 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.72', 'N/A', '$96.68', ' 94.9129 USD ', 'N/A', 'N/A', 'N/A', 'N/A', '$95.23', ' 94.2556 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(float... | {
"ann_volatility": 0.21350000000000002,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0065 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$101.49', 'N/A', ' 101.0645 USD ', '$100.48', 'N/A', '$103.43', ' 104.9337 USD ', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$101.49', 'N/A', ' 101.0645 USD ', '$100.48', 'N/A', '$103.43', ' 104.9337 USD ', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(... | {
"ann_volatility": 0.23170000000000002,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0066 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$191.0, Strike=$265.0, T=1.28y, Rate=3.64%, Vol=29.13% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 191.0, 265.0, 1.28, 0.0364, 0.026, 0.2913
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 6.429,
"clean_count": null,
"delta": 0.2082,
"status": null
} | 1 |
finquant-eval-0067 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$238.0, Strike=$122.0, T=1.52y, Rate=3.4099999999999997%, Vol=15.160000000000002% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 238.0, 122.0, 1.52, 0.0341, 0.0175, 0.1516
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 115.9158,
"clean_count": null,
"delta": 0.9737,
"status": null
} | 1 |
finquant-eval-0068 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0069 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$229.0, Strike=$233.0, T=1.71y, Rate=5.680000000000001%, Vol=21.4% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 229.0, 233.0, 1.71, 0.0568, 0.0044, 0.214
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 33.1388,
"clean_count": null,
"delta": 0.6499,
"status": null
} | 1 |
finquant-eval-0070 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$260.0, Strike=$73.0, T=0.31y, Rate=2.5%, Vol=16.470000000000002% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 260.0, 73.0, 0.31, 0.025, 0.0177, 0.1647
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T)... | {
"ann_volatility": null,
"call_price": 186.1409,
"clean_count": null,
"delta": 0.9945,
"status": null
} | 1 |
finquant-eval-0071 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$204.0, Strike=$67.0, T=1.75y, Rate=5.84%, Vol=17.36% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 204.0, 67.0, 1.75, 0.0584, 0.0177, 0.1736
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 137.2871,
"clean_count": null,
"delta": 0.9695,
"status": null
} | 1 |
finquant-eval-0072 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0073 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$141.0, Strike=$263.0, T=-0.5 | import json
if -0.5 <= 0:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Time to maturity T cannot be negative."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0074 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 101.1635 USD ', 'N/A', '$102.93', '$101.27', '$100.68', ' 101.9144 USD ', 'N/A', ' 101.2278 USD ', ' 102.1425 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 101.1635 USD ', 'N/A', '$102.93', '$101.27', '$100.68', ' 101.9144 USD ', 'N/A', ' 101.2278 USD ', ' 102.1425 USD ', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.199,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0075 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$233.0, Strike=$264.0, T=0.51y, Rate=2.19%, Vol=39.97% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 233.0, 264.0, 0.51, 0.0219, 0.0056, 0.3997
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 15.917,
"clean_count": null,
"delta": 0.3941,
"status": null
} | 1 |
finquant-eval-0076 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.53', '$102.52', 'N/A', ' 100.9557 USD ', 'N/A', '$99.63', ' 101.0395 USD ', 'N/A', ' 98.8376 USD ', ' 99.1493 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.53', '$102.52', 'N/A', ' 100.9557 USD ', 'N/A', '$99.63', ' 101.0395 USD ', 'N/A', ' 98.8376 USD ', ' 99.1493 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
t... | {
"ann_volatility": 0.2441,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0077 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.94', ' 98.2977 USD ', ' 97.1083 USD ', '$95.83', 'N/A', ' 97.9515 USD ', ' 96.3418 USD ', ' 95.1125 USD ', ' 94.6308 USD ', '$95.54'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.94', ' 98.2977 USD ', ' 97.1083 USD ', '$95.83', 'N/A', ' 97.9515 USD ', ' 96.3418 USD ', ' 95.1125 USD ', ' 94.6308 USD ', '$95.54']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str !... | {
"ann_volatility": 0.21030000000000001,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0078 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.43', 'N/A', '$100.32', ' 99.7497 USD ', ' 101.6548 USD ', '$102.96', ' 104.8052 USD ', '$106.34', 'N/A', ' 106.4568 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.43', 'N/A', '$100.32', ' 99.7497 USD ', ' 101.6548 USD ', '$102.96', ' 104.8052 USD ', '$106.34', 'N/A', ' 106.4568 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.1592,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0079 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$112.0, Strike=$261.0, T=0.35y, Rate=3.85%, Vol=34.18% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 112.0, 261.0, 0.35, 0.0385, 0.0271, 0.3418
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 0.0001,
"clean_count": null,
"delta": 0,
"status": null
} | 1 |
finquant-eval-0080 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$152.0, Strike=$162.0, T=-0.5 | import json
if -0.5 <= 0:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Time to maturity T cannot be negative."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0081 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$124.0, Strike=$227.0, T=0.47y, Rate=5.0%, Vol=21.87% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 124.0, 227.0, 0.47, 0.05, 0.0261, 0.2187
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T)... | {
"ann_volatility": null,
"call_price": 0.0002,
"clean_count": null,
"delta": 0.0001,
"status": null
} | 1 |
finquant-eval-0082 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.1069 USD ', ' 98.7060 USD ', '$97.91', ' 98.3548 USD ', '$98.26', ' 99.7298 USD ', 'N/A', ' 99.9997 USD ', 'N/A', ' 101.5862 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.1069 USD ', ' 98.7060 USD ', '$97.91', ' 98.3548 USD ', '$98.26', ' 99.7298 USD ', 'N/A', ' 99.9997 USD ', 'N/A', ' 101.5862 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str !=... | {
"ann_volatility": 0.1623,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0083 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$141.0, Strike=$89.0, T=0.64y, Rate=1.0699999999999998%, Vol=36.82% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 141.0, 89.0, 0.64, 0.0107, 0.0212, 0.3682
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 51.5751,
"clean_count": null,
"delta": 0.9413,
"status": null
} | 1 |
finquant-eval-0084 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 98.9063 USD ', '$99.77', '$100.73', ' 99.4509 USD ', '$98.36', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 98.9063 USD ', '$99.77', '$100.73', ' 99.4509 USD ', '$98.36', 'N/A', 'N/A', 'N/A', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(floa... | {
"ann_volatility": 0.1807,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0085 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$217.0, Strike=$176.0, T=1.32y, Rate=1.3299999999999998%, Vol=44.97% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 217.0, 176.0, 1.32, 0.0133, 0.0019, 0.4497
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 65.0361,
"clean_count": null,
"delta": 0.7539,
"status": null
} | 1 |
finquant-eval-0086 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$150.0, Strike=$68.0, T=1.48y, Rate=5.4399999999999995%, Vol=21.22% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 150.0, 68.0, 1.48, 0.0544, 0.0146, 0.2122
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 84.057,
"clean_count": null,
"delta": 0.9783000000000001,
"status": null
} | 1 |
finquant-eval-0087 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$122.0, Strike=$124.0, T=1.71y, Rate=2.22%, Vol=24.11% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 122.0, 124.0, 1.71, 0.0222, 0.0224, 0.2411
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 13.868,
"clean_count": null,
"delta": 0.5214,
"status": null
} | 1 |
finquant-eval-0088 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$221.0, Strike=$254.0, T=1.71y, Rate=5.04%, Vol=23.23% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 221.0, 254.0, 1.71, 0.0504, 0.0029, 0.2323
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 21.272,
"clean_count": null,
"delta": 0.48210000000000003,
"status": null
} | 1 |
finquant-eval-0089 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0090 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$108.0, Strike=$254.0, T=0.93y, Rate=2.25%, Vol=29.79% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 108.0, 254.0, 0.93, 0.0225, 0.0117, 0.2979
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 0.0217,
"clean_count": null,
"delta": 0.0025,
"status": null
} | 1 |
finquant-eval-0091 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.8118 USD ', 'N/A', ' 102.3160 USD ', ' 100.2882 USD ', ' 100.9106 USD ', ' 100.6378 USD ', '$101.02', '$101.66', '$101.76', ' 103.5546 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.8118 USD ', 'N/A', ' 102.3160 USD ', ' 100.2882 USD ', ' 100.9106 USD ', ' 100.6378 USD ', '$101.02', '$101.66', '$101.76', ' 103.5546 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and cle... | {
"ann_volatility": 0.2015,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0092 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$100.89', 'N/A', ' 98.5839 USD ', 'N/A', 'N/A', '$99.86', ' 98.2057 USD ', '$98.62', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$100.89', 'N/A', ' 98.5839 USD ', 'N/A', 'N/A', '$99.86', ' 98.2057 USD ', '$98.62', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(floa... | {
"ann_volatility": 0.2556,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0093 | Real-World Data Wrangling | true | [Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--'] | import json
feed = ["N/A", "CORRUPTED", "$--"]
valid = [x for x in feed if x.replace("$","").replace(".","").isdigit()]
if len(valid) < 2:
print(json.dumps({"status": "TRAP_DETECTED", "reason": "Insufficient valid numerical data."})) | {
"ann_volatility": null,
"call_price": null,
"clean_count": null,
"delta": null,
"status": "TRAP_DETECTED"
} | 1 |
finquant-eval-0094 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$88.0, Strike=$118.0, T=0.6y, Rate=3.66%, Vol=14.08% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 88.0, 118.0, 0.6, 0.0366, 0.0013, 0.1408
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T)... | {
"ann_volatility": null,
"call_price": 0.0223,
"clean_count": null,
"delta": 0.0073,
"status": null
} | 1 |
finquant-eval-0095 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.5003 USD ', '$101.80', 'N/A', ' 101.3547 USD ', ' 101.0645 USD ', ' 101.9130 USD ', ' 100.0924 USD ', 'N/A', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.5003 USD ', '$101.80', 'N/A', ' 101.3547 USD ', ' 101.0645 USD ', ' 101.9130 USD ', ' 100.0924 USD ', 'N/A', 'N/A', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.1756,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0096 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$183.0, Strike=$53.0, T=0.84y, Rate=5.63%, Vol=25.900000000000002% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 183.0, 53.0, 0.84, 0.0563, 0.0202, 0.259
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T)... | {
"ann_volatility": null,
"call_price": 129.3692,
"clean_count": null,
"delta": 0.9832000000000001,
"status": null
} | 1 |
finquant-eval-0097 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$288.0, Strike=$239.0, T=1.26y, Rate=5.390000000000001%, Vol=17.73% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 288.0, 239.0, 1.26, 0.0539, 0.0141, 0.1773
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * ... | {
"ann_volatility": null,
"call_price": 62.481700000000004,
"clean_count": null,
"delta": 0.8854000000000001,
"status": null
} | 1 |
finquant-eval-0098 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$98.46', '$98.46', '$97.88', ' 97.7325 USD ', 'N/A', '$96.11', '$95.75', 'N/A', ' 96.8166 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$98.46', '$98.46', '$97.88', ' 97.7325 USD ', 'N/A', '$96.11', '$95.75', 'N/A', ' 96.8166 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append... | {
"ann_volatility": 0.1514,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0099 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$63.0, Strike=$191.0, T=1.12y, Rate=4.02%, Vol=30.659999999999997% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 63.0, 191.0, 1.12, 0.0402, 0.0054, 0.3066
d1 = (np.log(S/K) + (r - q + 0.5 * sigma**2) * T) / (sigma * np.sqrt(T))
d2 = d1 - sigma * np.sqrt(T)
price = S * np.exp(-q * T) * norm.cdf(d1) - K * np.exp(-r * T) * norm.cdf(d2)
delta = np.exp(-q * T... | {
"ann_volatility": null,
"call_price": 0.0044,
"clean_count": null,
"delta": 0.0009000000000000001,
"status": null
} | 1 |
finquant-eval-0100 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.5747 USD ', 'N/A', 'N/A', '$101.36', 'N/A', '$104.33', 'N/A', 'N/A', ' 100.7607 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.5747 USD ', 'N/A', 'N/A', '$101.36', 'N/A', '$104.33', 'N/A', 'N/A', ' 100.7607 USD ', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(floa... | {
"ann_volatility": 0.42250000000000004,
"call_price": null,
"clean_count": 5,
"delta": null,
"status": null
} | 1 |
YAML Metadata Warning:empty or missing yaml metadata in repo card
Check out the documentation for more information.
license: mit task_categories: - text-generation - reinforcement-learning language: - en tags: - finance - quant - rlvr - grpo - python - synthetic - data-wrangling size_categories: - 1K<n<10K
π Financial RLVR & Data Wrangling Benchmark Suite
1,000 Execution-Verified Trajectories for Zero-Hallucination Financial Reasoning
π₯ Empirical Proof β’ β‘ Quickstart β’ π Dataset Breakdown β’ πΌ Enterprise Edition
π‘ Why this dataset exists: Standard open-source LLMs severely fail on financial code execution due to floating-point drift, unparsed messy feed strings (
$,N/A), and mathematical hallucinations under zero-shot prompting. This dataset forces models to reason via executable Python code with strict AST & runtime verification.
π₯ Empirical Proof & Benchmark Results
We benchmarked leading open-weights base models before and after SFT / GRPO fine-tuning on this dataset suite.
Evaluation was measured using Pass@1 Accuracy (strict $1e-3$ floating-point tolerance + correct JSON payload execution) across 200 held-out test prompts.
π Pass@1 Performance Comparison
| Model Architecture | Baseline Pass@1 | Fine-Tuned (With Dataset) Pass@1 | Trap Detection Rate | Pass@1 Delta |
|---|---|---|---|---|
| Qwen-2.5-Coder-3B-Instruct | 34.2% | 83.5% | 94.0% | +144.1% |
| DeepSeek-R1-Distill-Qwen-8B | 52.0% | 89.2% | 96.5% | +71.5% |
| Llama-3.1-8B-Instruct | 38.5% | 81.0% | 91.2% | +110.3% |
π― Key Empirical Takeaways
- π‘οΈ 94%+ Anti-Overfitting Trap Success: Standard models hallucinate solutions even when given mathematically impossible inputs (e.g., negative time-to-maturity $T < 0$). Models trained on this dataset correctly trigger exception handling (
TRAP_DETECTED). - π§Ή Clean Feed Wrangling Rate: Jumped from 28.4% to 91.5% on raw, uncleaned currency inputs (
"$1,250.50 USD","N/A","CORRUPTED"). - β‘ Ultra-Compact Footprint: Fine-tuning on just 1,000 samples yields over 80%+ execution accuracy, proving high-density algorithmic dataset quality > raw token volume.
β‘ Quickstart
No authentication required. Load the dataset in 1 line of code:
from datasets import load_dataset
# Load 1,000 verified reasoning trajectories
dataset = load_dataset("coslinedev/financial-rlvr-1k-teaser")
# Inspect the first sample
print(dataset["train"][0])
Load via PandasPythonimport pandas as pd
url = "[https://huggingface.co/datasets/coslinedev/financial-rlvr-1k-teaser/raw/main/finquant_eval_1000_teaser.jsonl](https://huggingface.co/datasets/coslinedev/financial-rlvr-1k-teaser/raw/main/finquant_eval_1000_teaser.jsonl)"
df = pd.read_json(url, lines=True)
print(f"β
Successfully loaded {len(df)} verified samples!")
π Dataset Architecture [ 1,000 VERIFIED SAMPLES ]
|
+-------------------------------------+-------------------------------------+
| | |
v v v
π Quant Derivatives (70%) π§Ή Dirty Wrangling (15%) πͺ€ Anti-Overfitting Traps (15%)
β’ Black-Scholes Pricing β’ Raw String Data Cleaning β’ Negative Maturity (T < 0)
β’ Greeks (Delta, Gamma, Vega) β’ Missing Value Interpolation β’ Negative Volatility (Ο β€ 0)
β’ Volatility Surface / Yields β’ Unstructured Currency Feeds β’ Corrupted Data Rejection
π¬ 4-Stage Verification SandboxUnlike web-scraped text datasets, every single sample in this repository is 100% execution-verified. A sample receives total_reward = 1.0 ONLY if it passes all 4 sandbox checkpoints:[ Model Code Output ]
β
ββββΊ 1. AST Syntax Parser (20%) βββββββββΊ Ensures zero syntax/indentation errors
ββββΊ 2. Quant Keyword Validator (25%) βββΊ Validates use of numpy, pandas, scipy, re
ββββΊ 3. Python Execution Sandbox (30%) ββΊ Executes code in isolated runtime environment
ββββΊ 4. JSON Payload Matcher (25%) βββββΊ Validates numerical precision within 1e-3 tolerance
β
βΌ
[ REWARD = 1.00 ]
π Schema DefinitionFieldTypeDescriptionidstringUnique sample identifier (finquant-eval-0001)domainstringTask category (Options & Derivatives, Real-World Data Wrangling)is_edge_casebooleanTrue if the sample represents a logic trap/corrupted inputpromptstringThe instruction given to the modelcode_solutionstringExecutable Python script generating JSON outputexpected_payloaddictGround-truth JSON payload expected from executiontotal_rewardfloatVerification score (1.0 = 100% pass)JSON{
"id": "finquant-eval-0042",
"domain": "Real-World Data Wrangling",
"is_edge_case": true,
"prompt": "[Dirty Data] Calculate Volatility from invalid feed: ['N/A', 'CORRUPTED', '$--']",
"code_solution": "import json\nfeed = ['N/A', 'CORRUPTED', '$--']\nvalid = [x for x in feed if x.replace('$','').replace('.','').isdigit()]\nif len(valid) < 2:\n print(json.dumps({'status': 'TRAP_DETECTED', 'reason': 'Insufficient valid numerical data.'}))",
"expected_payload": {
"status": "TRAP_DETECTED"
},
"total_reward": 1.0
}
πΌ Full Enterprise Dataset (50,000 Samples)This repository serves as the 1,000-sample Public Benchmark & Evaluation Teaser.For institutional AI labs, hedge funds, and LLM providers requiring our complete 50,000-sample Enterprise Dataset, custom execution sandboxes, proprietary data synthesis pipelines, or domain-specific dataset customization:π§ Contact Email: contact@cosline.devπ Organization: Cosline Devπ€ Use Cases: Institutional Quant Models, Automated Financial Analysts, Code-Execution LLM Tuning.
- Downloads last month
- 27