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-0201 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$251.0, Strike=$190.0, T=0.64y, Rate=1.25%, Vol=23.330000000000002% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 251.0, 190.0, 0.64, 0.0125, 0.0151, 0.2333
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": 61.3271,
"clean_count": null,
"delta": 0.9334,
"status": null
} | 1 |
finquant-eval-0202 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 96.6993 USD ', ' 97.8668 USD ', '$98.46', '$98.71', ' 98.1467 USD ', ' 97.5270 USD ', '$98.13', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 96.6993 USD ', ' 97.8668 USD ', '$98.46', '$98.71', ' 98.1467 USD ', ' 97.5270 USD ', '$98.13', '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.24020000000000002,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0203 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$299.0, Strike=$244.0, T=0.56y, Rate=3.08%, Vol=23.82% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 299.0, 244.0, 0.56, 0.0308, 0.0028, 0.2382
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": 61.2211,
"clean_count": null,
"delta": 0.9047000000000001,
"status": null
} | 1 |
finquant-eval-0204 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$56.0, Strike=$266.0, T=1.25y, Rate=4.1000000000000005%, Vol=12.25% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 56.0, 266.0, 1.25, 0.041, 0.028, 0.1225
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-0205 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$75.0, Strike=$170.0, T=1.85y, Rate=2.73%, Vol=31.230000000000004% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 75.0, 170.0, 1.85, 0.0273, 0.0153, 0.3123
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.5355,
"clean_count": null,
"delta": 0.046900000000000004,
"status": null
} | 1 |
finquant-eval-0206 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 98.7308 USD ', '$100.09', '$99.11', '$98.63', ' 99.3055 USD ', '$99.79', ' 100.5306 USD ', ' 101.5690 USD ', ' 101.0070 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 98.7308 USD ', '$100.09', '$99.11', '$98.63', ' 99.3055 USD ', '$99.79', ' 100.5306 USD ', ' 101.5690 USD ', ' 101.0070 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.1507,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0207 | 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-0208 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.97', ' 101.4008 USD ', 'N/A', '$102.44', ' 100.3994 USD ', '$101.73', ' 102.7839 USD ', 'N/A', 'N/A', '$104.59'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.97', ' 101.4008 USD ', 'N/A', '$102.44', ' 100.3994 USD ', '$101.73', ' 102.7839 USD ', 'N/A', 'N/A', '$104.59']
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.226,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0209 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$134.0, Strike=$67.0, T=1.82y, Rate=5.92%, Vol=17.91% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 134.0, 67.0, 1.82, 0.0592, 0.0275, 0.1791
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": 67.3074,
"clean_count": null,
"delta": 0.9506,
"status": null
} | 1 |
finquant-eval-0210 | 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-0211 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.75', 'N/A', ' 97.9464 USD ', 'N/A', 'N/A', 'N/A', ' 95.6480 USD ', 'N/A', '$94.19', ' 92.6496 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.75', 'N/A', ' 97.9464 USD ', 'N/A', 'N/A', 'N/A', ' 95.6480 USD ', 'N/A', '$94.19', ' 92.6496 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.appen... | {
"ann_volatility": 0.12430000000000001,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0212 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.82', '$102.38', 'N/A', ' 103.3520 USD ', 'N/A', ' 101.2457 USD ', ' 101.5500 USD ', ' 102.5094 USD ', 'N/A', ' 104.7720 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.82', '$102.38', 'N/A', ' 103.3520 USD ', 'N/A', ' 101.2457 USD ', ' 101.5500 USD ', ' 102.5094 USD ', 'N/A', ' 104.7720 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.21810000000000002,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0213 | 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-0214 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.2561 USD ', '$100.22', ' 100.1130 USD ', '$100.70', ' 102.4040 USD ', 'N/A', 'N/A', 'N/A', 'N/A', ' 102.2776 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.2561 USD ', '$100.22', ' 100.1130 USD ', '$100.70', ' 102.4040 USD ', 'N/A', 'N/A', 'N/A', 'N/A', ' 102.2776 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.1389,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0215 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$155.0, Strike=$275.0, T=0.52y, Rate=5.43%, Vol=20.54% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 155.0, 275.0, 0.52, 0.0543, 0.0145, 0.2054
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.0007,
"clean_count": null,
"delta": 0.0001,
"status": null
} | 1 |
finquant-eval-0216 | 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-0217 | 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-0218 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.0816 USD ', ' 97.3935 USD ', '$98.80', ' 99.5886 USD ', '$100.88', 'N/A', ' 98.9671 USD ', ' 100.5847 USD ', '$100.22', '$100.30'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.0816 USD ', ' 97.3935 USD ', '$98.80', ' 99.5886 USD ', '$100.88', 'N/A', ' 98.9671 USD ', ' 100.5847 USD ', '$100.22', '$100.30']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '... | {
"ann_volatility": 0.21430000000000002,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0219 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$126.0, Strike=$84.0, T=1.35y, Rate=3.36%, Vol=18.529999999999998% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 126.0, 84.0, 1.35, 0.0336, 0.0019, 0.1853
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": 45.5486,
"clean_count": null,
"delta": 0.9832000000000001,
"status": null
} | 1 |
finquant-eval-0220 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 98.7429 USD ', 'N/A', '$98.70', '$98.32', '$99.07', 'N/A', 'N/A', ' 95.2494 USD ', '$94.06', ' 93.1795 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 98.7429 USD ', 'N/A', '$98.70', '$98.32', '$99.07', 'N/A', 'N/A', ' 95.2494 USD ', '$94.06', ' 93.1795 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.2348,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0221 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.21', ' 99.3743 USD ', ' 100.6959 USD ', 'N/A', ' 101.2545 USD ', 'N/A', '$100.27', ' 99.7334 USD ', 'N/A', ' 98.1218 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.21', ' 99.3743 USD ', ' 100.6959 USD ', 'N/A', ' 101.2545 USD ', 'N/A', '$100.27', ' 99.7334 USD ', 'N/A', ' 98.1218 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.2073,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0222 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$266.0, Strike=$237.0, T=0.83y, Rate=4.67%, Vol=38.59% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 266.0, 237.0, 0.83, 0.0467, 0.0043, 0.3859
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": 56.0011,
"clean_count": null,
"delta": 0.7246,
"status": null
} | 1 |
finquant-eval-0223 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$281.0, Strike=$253.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-0224 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 102.1726 USD ', 'N/A', ' 99.9161 USD ', ' 99.9399 USD ', '$101.61', '$101.44', '$100.21', 'N/A', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 102.1726 USD ', 'N/A', ' 99.9161 USD ', ' 99.9399 USD ', '$101.61', '$101.44', '$100.21', '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.26430000000000003,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0225 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$266.0, Strike=$267.0, T=0.91y, Rate=5.79%, Vol=44.12% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 266.0, 267.0, 0.91, 0.0579, 0.0165, 0.4412
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": 47.4536,
"clean_count": null,
"delta": 0.6053000000000001,
"status": null
} | 1 |
finquant-eval-0226 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$98.40', '$97.07', ' 95.6409 USD ', '$96.88', '$97.85', 'N/A', ' 98.8284 USD ', '$99.54', 'N/A', ' 102.8135 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$98.40', '$97.07', ' 95.6409 USD ', '$96.88', '$97.85', 'N/A', ' 98.8284 USD ', '$99.54', 'N/A', ' 102.8135 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cle... | {
"ann_volatility": 0.27040000000000003,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0227 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.7919 USD ', ' 98.9654 USD ', '$98.02', 'N/A', ' 99.4009 USD ', '$99.15', '$97.17', ' 97.0396 USD ', '$95.31', '$95.70'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.7919 USD ', ' 98.9654 USD ', '$98.02', 'N/A', ' 99.4009 USD ', '$99.15', '$97.17', ' 97.0396 USD ', '$95.31', '$95.70']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.19640000000000002,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0228 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$119.0, Strike=$175.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-0229 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$181.0, Strike=$261.0, T=0.4y, Rate=1.11%, Vol=15.43% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 181.0, 261.0, 0.4, 0.0111, 0.0161, 0.1543
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.0004,
"clean_count": null,
"delta": 0.0001,
"status": null
} | 1 |
finquant-eval-0230 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$94.0, Strike=$289.0, T=0.45y, Rate=3.15%, Vol=32.129999999999995% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 94.0, 289.0, 0.45, 0.0315, 0.0137, 0.3213
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-0231 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$79.0, Strike=$196.0, T=1.93y, Rate=5.67%, Vol=29.360000000000003% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 79.0, 196.0, 1.93, 0.0567, 0.0066, 0.2936
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.40890000000000004,
"clean_count": null,
"delta": 0.036500000000000005,
"status": null
} | 1 |
finquant-eval-0232 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.29', 'N/A', 'N/A', ' 97.8539 USD ', '$99.63', 'N/A', 'N/A', '$97.51', '$99.05', '$100.88'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.29', 'N/A', 'N/A', ' 97.8539 USD ', '$99.63', 'N/A', 'N/A', '$97.51', '$99.05', '$100.88']
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(c... | {
"ann_volatility": 0.3695,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0233 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$160.0, Strike=$261.0, T=0.97y, Rate=4.3999999999999995%, Vol=37.19% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 160.0, 261.0, 0.97, 0.044, 0.0256, 0.3719
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": 3.346,
"clean_count": null,
"delta": 0.1315,
"status": null
} | 1 |
finquant-eval-0234 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 103.3019 USD ', '$101.91', ' 100.5034 USD ', 'N/A', ' 101.1076 USD ', ' 102.3990 USD ', ' 100.7743 USD ', 'N/A', ' 101.2619 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 103.3019 USD ', '$101.91', ' 100.5034 USD ', 'N/A', ' 101.1076 USD ', ' 102.3990 USD ', ' 100.7743 USD ', 'N/A', ' 101.2619 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.28150000000000003,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0235 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$150.0, Strike=$267.0, T=0.64y, Rate=2.82%, Vol=21.349999999999998% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 150.0, 267.0, 0.64, 0.0282, 0.0122, 0.2135
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.004,
"clean_count": null,
"delta": 0.0006000000000000001,
"status": null
} | 1 |
finquant-eval-0236 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.4271 USD ', '$101.60', ' 100.1316 USD ', '$100.98', ' 99.0369 USD ', 'N/A', ' 95.9377 USD ', 'N/A', '$96.47', '$94.97'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.4271 USD ', '$101.60', ' 100.1316 USD ', '$100.98', ' 99.0369 USD ', 'N/A', ' 95.9377 USD ', 'N/A', '$96.47', '$94.97']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.2523,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0237 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$277.0, Strike=$247.0, T=0.68y, Rate=1.69%, Vol=44.12% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 277.0, 247.0, 0.68, 0.0169, 0.0034, 0.4412
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.7881,
"clean_count": null,
"delta": 0.6976,
"status": null
} | 1 |
finquant-eval-0238 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$98.73', 'N/A', '$101.21', '$101.41', '$100.17', 'N/A', 'N/A', '$97.02', ' 96.0722 USD ', '$94.18'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$98.73', 'N/A', '$101.21', '$101.41', '$100.17', 'N/A', 'N/A', '$97.02', ' 96.0722 USD ', '$94.18']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.append(flo... | {
"ann_volatility": 0.28500000000000003,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0239 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$100.28', 'N/A', '$102.82', 'N/A', 'N/A', 'N/A', '$103.32', '$103.77', '$105.49', ' 106.2679 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$100.28', 'N/A', '$102.82', 'N/A', 'N/A', 'N/A', '$103.32', '$103.77', '$105.49', ' 106.2679 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(flo... | {
"ann_volatility": 0.13920000000000002,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0240 | 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-0241 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$103.15', '$101.66', '$102.56', 'N/A', 'N/A', 'N/A', ' 98.0784 USD ', '$96.50', '$96.25'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$103.15', '$101.66', '$102.56', 'N/A', 'N/A', 'N/A', ' 98.0784 USD ', '$96.50', '$96.25']
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.4062,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0242 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.29', ' 98.7812 USD ', ' 100.0514 USD ', 'N/A', ' 103.4050 USD ', '$102.82', ' 101.2437 USD ', 'N/A', '$100.88', ' 101.6204 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.29', ' 98.7812 USD ', ' 100.0514 USD ', 'N/A', ' 103.4050 USD ', '$102.82', ' 101.2437 USD ', 'N/A', '$100.88', ' 101.6204 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.2424,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0243 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$100.96', 'N/A', ' 100.6264 USD ', ' 102.0488 USD ', 'N/A', '$102.12', ' 100.5195 USD ', ' 102.2553 USD ', '$101.78', '$101.99'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$100.96', 'N/A', ' 100.6264 USD ', ' 102.0488 USD ', 'N/A', '$102.12', ' 100.5195 USD ', ' 102.2553 USD ', '$101.78', '$101.99']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.1718,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0244 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$281.0, Strike=$107.0, T=0.53y, Rate=5.6899999999999995%, Vol=24.75% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 281.0, 107.0, 0.53, 0.0569, 0.0202, 0.2475
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": 174.1863,
"clean_count": null,
"delta": 0.9894000000000001,
"status": null
} | 1 |
finquant-eval-0245 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$104.0, Strike=$176.0, T=0.49y, Rate=3.37%, Vol=14.099999999999998% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 104.0, 176.0, 0.49, 0.0337, 0.0074, 0.141
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-0246 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$170.0, Strike=$87.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-0247 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', 'N/A', '$100.44', 'N/A', '$97.70', '$99.45', '$99.92', ' 99.2626 USD ', ' 99.0197 USD ', '$99.71'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', 'N/A', '$100.44', 'N/A', '$97.70', '$99.45', '$99.92', ' 99.2626 USD ', ' 99.0197 USD ', '$99.71']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.appen... | {
"ann_volatility": 0.2262,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0248 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 98.4169 USD ', '$97.44', 'N/A', ' 95.4557 USD ', ' 96.2617 USD ', ' 97.8364 USD ', 'N/A', '$97.82', ' 97.4096 USD ', '$97.06'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 98.4169 USD ', '$97.44', 'N/A', ' 95.4557 USD ', ' 96.2617 USD ', ' 97.8364 USD ', 'N/A', '$97.82', ' 97.4096 USD ', '$97.06']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.19260000000000002,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0249 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$109.0, Strike=$128.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-0250 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 100.1077 USD ', '$98.78', 'N/A', 'N/A', ' 97.5102 USD ', '$99.02', '$99.51', ' 99.8722 USD ', '$100.84'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 100.1077 USD ', '$98.78', 'N/A', 'N/A', ' 97.5102 USD ', '$99.02', '$99.51', ' 99.8722 USD ', '$100.84']
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.1719,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0251 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 101.5764 USD ', 'N/A', 'N/A', ' 102.0440 USD ', ' 103.3899 USD ', 'N/A', ' 103.9064 USD ', 'N/A', 'N/A', '$108.56'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 101.5764 USD ', 'N/A', 'N/A', ' 102.0440 USD ', ' 103.3899 USD ', 'N/A', ' 103.9064 USD ', 'N/A', 'N/A', '$108.56']
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.2551,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0252 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 98.8532 USD ', 'N/A', 'N/A', ' 99.4363 USD ', '$100.69', ' 101.8085 USD ', ' 99.8529 USD ', '$101.50', '$100.49'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 98.8532 USD ', 'N/A', 'N/A', ' 99.4363 USD ', '$100.69', ' 101.8085 USD ', ' 99.8529 USD ', '$101.50', '$100.49']
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.2233,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0253 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$110.0, Strike=$167.0, T=0.78y, Rate=5.12%, Vol=38.87% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 110.0, 167.0, 0.78, 0.0512, 0.0247, 0.3887
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.7445,
"clean_count": null,
"delta": 0.15940000000000001,
"status": null
} | 1 |
finquant-eval-0254 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$244.0, Strike=$291.0, T=0.35y, Rate=1.83%, Vol=43.49% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 244.0, 291.0, 0.35, 0.0183, 0.006, 0.4349
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": 10.2477,
"clean_count": null,
"delta": 0.2942,
"status": null
} | 1 |
finquant-eval-0255 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$69.0, Strike=$207.0, T=1.74y, Rate=5.33%, Vol=34.39% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 69.0, 207.0, 1.74, 0.0533, 0.023, 0.3439
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.179,
"clean_count": null,
"delta": 0.0181,
"status": null
} | 1 |
finquant-eval-0256 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.03', '$98.43', '$97.49', '$96.99', ' 96.5878 USD ', ' 96.3826 USD ', ' 97.6545 USD ', ' 97.9163 USD ', '$98.12', '$98.16'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.03', '$98.43', '$97.49', '$96.99', ' 96.5878 USD ', ' 96.3826 USD ', ' 97.6545 USD ', ' 97.9163 USD ', '$98.12', '$98.16']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.1086,
"call_price": null,
"clean_count": 11,
"delta": null,
"status": null
} | 1 |
finquant-eval-0257 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 102.0215 USD ', 'N/A', 'N/A', ' 104.9517 USD ', '$106.93', '$106.11', ' 107.1748 USD ', '$108.85', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 102.0215 USD ', 'N/A', 'N/A', ' 104.9517 USD ', '$106.93', '$106.11', ' 107.1748 USD ', '$108.85', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: clea... | {
"ann_volatility": 0.1947,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0258 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$168.0, Strike=$237.0, T=0.84y, Rate=1.59%, Vol=44.66% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 168.0, 237.0, 0.84, 0.0159, 0.0231, 0.4466
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": 8.6402,
"clean_count": null,
"delta": 0.2526,
"status": null
} | 1 |
finquant-eval-0259 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$178.0, Strike=$236.0, T=0.35y, Rate=5.71%, Vol=28.64% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 178.0, 236.0, 0.35, 0.0571, 0.0157, 0.2864
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.8348,
"clean_count": null,
"delta": 0.06720000000000001,
"status": null
} | 1 |
finquant-eval-0260 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$53.0, Strike=$204.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-0261 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$282.0, Strike=$70.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-0262 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$101.95', ' 103.1823 USD ', 'N/A', 'N/A', ' 102.6949 USD ', ' 101.5334 USD ', '$99.73', '$101.54', ' 99.5768 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$101.95', ' 103.1823 USD ', 'N/A', 'N/A', ' 102.6949 USD ', ' 101.5334 USD ', '$99.73', '$101.54', ' 99.5768 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.2666,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0263 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.4189 USD ', '$100.62', 'N/A', 'N/A', 'N/A', ' 100.8942 USD ', ' 100.4319 USD ', ' 101.1210 USD ', 'N/A', ' 100.5995 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.4189 USD ', '$100.62', 'N/A', 'N/A', 'N/A', ' 100.8942 USD ', ' 100.4319 USD ', ' 101.1210 USD ', 'N/A', ' 100.5995 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.11760000000000001,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0264 | 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-0265 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$124.0, Strike=$58.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-0266 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.21', ' 99.5662 USD ', 'N/A', '$100.89', ' 101.0176 USD ', '$99.55', 'N/A', ' 101.9585 USD ', 'N/A', '$102.83'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.21', ' 99.5662 USD ', 'N/A', '$100.89', ' 101.0176 USD ', '$99.55', 'N/A', ' 101.9585 USD ', 'N/A', '$102.83']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cle... | {
"ann_volatility": 0.2048,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0267 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$257.0, Strike=$260.0, T=0.86y, Rate=1.6099999999999999%, Vol=36.11% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 257.0, 260.0, 0.86, 0.0161, 0.0249, 0.3611
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": 31.3936,
"clean_count": null,
"delta": 0.5323,
"status": null
} | 1 |
finquant-eval-0268 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 97.7720 USD ', '$96.42', ' 97.0269 USD ', '$96.55', ' 96.3812 USD ', 'N/A', '$94.08', '$93.34', '$91.70'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 97.7720 USD ', '$96.42', ' 97.0269 USD ', '$96.55', ' 96.3812 USD ', 'N/A', '$94.08', '$93.34', '$91.70']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: clea... | {
"ann_volatility": 0.16870000000000002,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0269 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$138.0, Strike=$267.0, T=0.77y, Rate=3.88%, Vol=22.6% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 138.0, 267.0, 0.77, 0.0388, 0.0022, 0.226
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.0073,
"clean_count": null,
"delta": 0.001,
"status": null
} | 1 |
finquant-eval-0270 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$105.0, Strike=$79.0, T=1.7y, Rate=1.47%, Vol=42.66% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 105.0, 79.0, 1.7, 0.0147, 0.0143, 0.4266
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": 34.8233,
"clean_count": null,
"delta": 0.7666000000000001,
"status": null
} | 1 |
finquant-eval-0271 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$99.05', 'N/A', ' 99.8455 USD ', 'N/A', '$100.21', ' 101.3131 USD ', 'N/A', 'N/A', '$104.01'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$99.05', 'N/A', ' 99.8455 USD ', 'N/A', '$100.21', ' 101.3131 USD ', 'N/A', 'N/A', '$104.01']
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.2053,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0272 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$100.81', 'N/A', 'N/A', '$102.47', ' 101.1779 USD ', ' 100.7161 USD ', '$100.77', ' 100.7458 USD ', ' 100.9628 USD ', ' 101.8303 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$100.81', 'N/A', 'N/A', '$102.47', ' 101.1779 USD ', ' 100.7161 USD ', '$100.77', ' 100.7458 USD ', ' 100.9628 USD ', ' 101.8303 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.1408,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0273 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$142.0, Strike=$234.0, T=1.83y, Rate=4.8%, Vol=42.58% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 142.0, 234.0, 1.83, 0.048, 0.0246, 0.4258
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": 11.6729,
"clean_count": null,
"delta": 0.2933,
"status": null
} | 1 |
finquant-eval-0274 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$131.0, Strike=$92.0, T=0.41y, Rate=1.5%, Vol=30.599999999999998% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 131.0, 92.0, 0.41, 0.015, 0.0172, 0.306
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": 38.9481,
"clean_count": null,
"delta": 0.9643,
"status": null
} | 1 |
finquant-eval-0275 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$100.58', ' 100.2737 USD ', '$99.07', ' 98.2995 USD ', '$96.69', '$98.00', 'N/A', 'N/A', '$97.07', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$100.58', ' 100.2737 USD ', '$99.07', ' 98.2995 USD ', '$96.69', '$98.00', 'N/A', 'N/A', '$97.07', '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.1675,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0276 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$97.55', ' 97.2901 USD ', 'N/A', '$95.73', '$94.13', 'N/A', 'N/A', ' 94.9641 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$97.55', ' 97.2901 USD ', 'N/A', '$95.73', '$94.13', 'N/A', 'N/A', ' 94.9641 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(float... | {
"ann_volatility": 0.2117,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0277 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$133.0, Strike=$98.0, T=1.84y, Rate=4.1000000000000005%, Vol=23.64% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 133.0, 98.0, 1.84, 0.041, 0.0125, 0.2364
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": 41.395,
"clean_count": null,
"delta": 0.8786,
"status": null
} | 1 |
finquant-eval-0278 | 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-0279 | 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-0280 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 101.3569 USD ', '$102.01', ' 101.6728 USD ', 'N/A', '$103.62', '$102.44', 'N/A', ' 100.8699 USD ', '$101.61', '$103.29'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 101.3569 USD ', '$102.01', ' 101.6728 USD ', 'N/A', '$103.62', '$102.44', 'N/A', ' 100.8699 USD ', '$101.61', '$103.29']
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.2039,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0281 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$200.0, Strike=$144.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-0282 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$98.39', ' 98.0898 USD ', ' 99.2881 USD ', '$100.65', ' 100.1924 USD ', '$101.24', ' 102.8355 USD ', 'N/A', ' 101.3323 USD ', '$99.84'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$98.39', ' 98.0898 USD ', ' 99.2881 USD ', '$100.65', ' 100.1924 USD ', '$101.24', ' 102.8355 USD ', 'N/A', ' 101.3323 USD ', '$99.84']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != ... | {
"ann_volatility": 0.2112,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0283 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$98.62', '$100.50', ' 98.6698 USD ', '$99.61', '$98.63', 'N/A', ' 99.6598 USD ', ' 101.1889 USD ', '$103.15', '$104.63'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$98.62', '$100.50', ' 98.6698 USD ', '$99.61', '$98.63', 'N/A', ' 99.6598 USD ', ' 101.1889 USD ', '$103.15', '$104.63']
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.2354,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0284 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$226.0, Strike=$249.0, T=0.32y, Rate=3.7699999999999996%, Vol=34.260000000000005% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 226.0, 249.0, 0.32, 0.0377, 0.0115, 0.3426
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": 9.6225,
"clean_count": null,
"delta": 0.35810000000000003,
"status": null
} | 1 |
finquant-eval-0285 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', '$99.32', ' 98.4164 USD ', 'N/A', '$98.00', 'N/A', 'N/A', '$98.79', 'N/A', ' 95.9629 USD ', ' 95.3719 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', '$99.32', ' 98.4164 USD ', 'N/A', '$98.00', 'N/A', 'N/A', '$98.79', 'N/A', ' 95.9629 USD ', ' 95.3719 USD ']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
try: cleaned.ap... | {
"ann_volatility": 0.1904,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0286 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 101.1079 USD ', 'N/A', ' 102.6330 USD ', ' 103.3002 USD ', ' 103.5830 USD ', ' 105.4501 USD ', '$103.66', 'N/A', ' 104.4043 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 101.1079 USD ', 'N/A', ' 102.6330 USD ', ' 103.3002 USD ', ' 103.5830 USD ', ' 105.4501 USD ', '$103.66', 'N/A', ' 104.4043 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.1825,
"call_price": null,
"clean_count": 8,
"delta": null,
"status": null
} | 1 |
finquant-eval-0287 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 100.0153 USD ', 'N/A', ' 100.9351 USD ', ' 98.9800 USD ', '$97.14', ' 97.2123 USD ', 'N/A', ' 99.5690 USD ', '$100.00', '$98.38'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 100.0153 USD ', 'N/A', ' 100.9351 USD ', ' 98.9800 USD ', '$97.14', ' 97.2123 USD ', 'N/A', ' 99.5690 USD ', '$100.00', '$98.38']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.24330000000000002,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0288 | Options & Derivatives | true | [Derivatives] Calculate Call Price for Spot=$183.0, Strike=$235.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-0289 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', '$98.56', ' 96.9516 USD ', 'N/A', 'N/A', '$96.02', 'N/A', '$93.21', '$92.93', '$94.38'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', '$98.56', ' 96.9516 USD ', 'N/A', 'N/A', '$96.02', 'N/A', '$93.21', '$92.93', '$94.38']
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(cle... | {
"ann_volatility": 0.24050000000000002,
"call_price": null,
"clean_count": 7,
"delta": null,
"status": null
} | 1 |
finquant-eval-0290 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.6210 USD ', '$100.80', '$99.81', ' 99.3097 USD ', ' 97.7692 USD ', '$98.57', '$96.80', '$97.49', ' 97.0164 USD ', '$98.83'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.6210 USD ', '$100.80', '$99.81', ' 99.3097 USD ', ' 97.7692 USD ', '$98.57', '$96.80', '$97.49', ' 97.0164 USD ', '$98.83']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and clean_str != '.':
... | {
"ann_volatility": 0.19210000000000002,
"call_price": null,
"clean_count": 11,
"delta": null,
"status": null
} | 1 |
finquant-eval-0291 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$128.0, Strike=$219.0, T=1.27y, Rate=3.0700000000000003%, Vol=43.04% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 128.0, 219.0, 1.27, 0.0307, 0.0104, 0.4304
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": 5.8288,
"clean_count": null,
"delta": 0.2058,
"status": null
} | 1 |
finquant-eval-0292 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 100.5329 USD ', ' 101.3238 USD ', 'N/A', '$102.85', '$104.71', ' 105.9612 USD ', ' 107.3430 USD ', '$106.21', ' 105.6813 USD '] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 100.5329 USD ', ' 101.3238 USD ', 'N/A', '$102.85', '$104.71', ' 105.9612 USD ', ' 107.3430 USD ', '$106.21', ' 105.6813 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.1587,
"call_price": null,
"clean_count": 9,
"delta": null,
"status": null
} | 1 |
finquant-eval-0293 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$257.0, Strike=$96.0, T=0.5y, Rate=4.279999999999999%, Vol=12.35% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 257.0, 96.0, 0.5, 0.0428, 0.0271, 0.1235
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": 159.5737,
"clean_count": null,
"delta": 0.9865,
"status": null
} | 1 |
finquant-eval-0294 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$65.0, Strike=$150.0, T=0.62y, Rate=2.27%, Vol=35.91% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 65.0, 150.0, 0.62, 0.0227, 0.0247, 0.3591
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.0119,
"clean_count": null,
"delta": 0.0024000000000000002,
"status": null
} | 1 |
finquant-eval-0295 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', ' 99.1111 USD ', '$98.50', ' 99.6196 USD ', ' 98.9373 USD ', '$98.70', ' 99.2990 USD ', ' 99.6150 USD ', ' 101.4438 USD ', ' 100.9213 USD ', 'N/A'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', ' 99.1111 USD ', '$98.50', ' 99.6196 USD ', ' 98.9373 USD ', '$98.70', ' 99.2990 USD ', ' 99.6150 USD ', ' 101.4438 USD ', ' 100.9213 USD ', 'N/A']
cleaned = []
for x in raw_feed:
clean_str = re.sub(r'[^0-9.]', '', str(x))
if clean_str and cl... | {
"ann_volatility": 0.14780000000000001,
"call_price": null,
"clean_count": 10,
"delta": null,
"status": null
} | 1 |
finquant-eval-0296 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$181.0, Strike=$87.0, T=1.74y, Rate=5.96%, Vol=19.06% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 181.0, 87.0, 1.74, 0.0596, 0.0073, 0.1906
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": 100.2898,
"clean_count": null,
"delta": 0.987,
"status": null
} | 1 |
finquant-eval-0297 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$206.0, Strike=$178.0, T=1.47y, Rate=5.4399999999999995%, Vol=23.599999999999998% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 206.0, 178.0, 1.47, 0.0544, 0.0062, 0.236
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": 46.5479,
"clean_count": null,
"delta": 0.8089000000000001,
"status": null
} | 1 |
finquant-eval-0298 | Real-World Data Wrangling | false | [Data Wrangling] Clean raw prices and get Volatility: [' $100.00 ', 'N/A', ' 97.4252 USD ', ' 96.6835 USD ', ' 94.8427 USD ', 'N/A', 'N/A', 'N/A', 'N/A', ' 95.2432 USD ', '$95.27'] | import numpy as np, pandas as pd, json, re
raw_feed = [' $100.00 ', 'N/A', ' 97.4252 USD ', ' 96.6835 USD ', ' 94.8427 USD ', 'N/A', 'N/A', 'N/A', 'N/A', ' 95.2432 USD ', '$95.27']
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.2034,
"call_price": null,
"clean_count": 6,
"delta": null,
"status": null
} | 1 |
finquant-eval-0299 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$110.0, Strike=$206.0, T=0.5y, Rate=2.88%, Vol=17.89% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 110.0, 206.0, 0.5, 0.0288, 0.0157, 0.1789
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-0300 | Options & Derivatives | false | [Options] Calculate European Call Price & Delta for Spot=$152.0, Strike=$155.0, T=0.45y, Rate=2.93%, Vol=23.94% | import numpy as np, json
from scipy.stats import norm
S, K, T, r, q, sigma = 152.0, 155.0, 0.45, 0.0293, 0.0113, 0.2394
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": 8.8885,
"clean_count": null,
"delta": 0.501,
"status": null
} | 1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.