Dataset Viewer
Auto-converted to Parquet Duplicate
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
End of preview. Expand in Data Studio

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

Hugging Face Dataset License: MIT Verification-Reward Pass@1 Boost

πŸ”₯ 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