1use std::{borrow::Borrow, collections::HashMap, sync::Arc};
19
20use arrow::{
21 array::{
22 Array, ArrayRef, BooleanArray, Float64Array, Float64Builder, Int32Array, ListArray,
23 ListBuilder, StringArray, UInt64Array,
24 },
25 datatypes::{DataType, Field, Schema},
26 error::ArrowError,
27 record_batch::RecordBatch,
28};
29use nautilus_model::{
30 data::{
31 CustomData, CustomDataTrait, Data,
32 greeks::{GreeksData, OptionGreekValues, PortfolioGreeks, YieldCurve},
33 },
34 identifiers::InstrumentId,
35};
36
37use super::{
38 ArrowSchemaProvider, DecodeDataFromRecordBatch, DecodeTypedFromRecordBatch,
39 EncodeToRecordBatch, EncodingError, StringColumnRef, extract_column_by_name,
40 extract_column_string, identifier_array_from_display, metadata_with_type_name,
41 record_batch_with_timestamps, record_batch_with_u64_timestamps, timestamp_data_type,
42};
43
44impl ArrowSchemaProvider for GreeksData {
45 fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
46 let mut fields = vec![
47 Field::new("ts_init", timestamp_data_type(), false),
48 Field::new("ts_event", timestamp_data_type(), false),
49 Field::new("instrument_id", DataType::Utf8, false),
50 Field::new("is_call", DataType::Boolean, false),
51 Field::new("strike", DataType::Float64, false),
52 Field::new("expiry", DataType::Int32, false),
53 Field::new("expiry_in_days", DataType::Int32, false),
54 Field::new("expiry_in_years", DataType::Float64, false),
55 Field::new("multiplier", DataType::Float64, false),
56 Field::new("quantity", DataType::Float64, false),
57 Field::new("underlying_price", DataType::Float64, false),
58 Field::new("interest_rate", DataType::Float64, false),
59 Field::new("cost_of_carry", DataType::Float64, false),
60 Field::new("vol", DataType::Float64, false),
61 Field::new("pnl", DataType::Float64, false),
62 Field::new("price", DataType::Float64, false),
63 ];
64
65 fields.extend(greek_fields());
66 fields.push(Field::new("itm_prob", DataType::Float64, false));
67 Schema::new_with_metadata(fields, metadata_with_type_name("GreeksData", metadata))
68 }
69}
70
71impl EncodeToRecordBatch for GreeksData {
72 fn encode_batch<T: Borrow<Self>>(
73 metadata: &HashMap<String, String>,
74 data: &[T],
75 ) -> Result<RecordBatch, ArrowError> {
76 let mut columns: Vec<ArrayRef> = vec![
77 Arc::new(UInt64Array::from_iter_values(
78 data.iter().map(|value| value.borrow().ts_init.as_u64()),
79 )),
80 Arc::new(UInt64Array::from_iter_values(
81 data.iter().map(|value| value.borrow().ts_event.as_u64()),
82 )),
83 Arc::new(identifier_array_from_display(
84 data.iter().map(|value| value.borrow().instrument_id),
85 )),
86 Arc::new(BooleanArray::from(
87 data.iter()
88 .map(|value| value.borrow().is_call)
89 .collect::<Vec<_>>(),
90 )),
91 Arc::new(Float64Array::from_iter_values(
92 data.iter().map(|value| value.borrow().strike),
93 )),
94 Arc::new(Int32Array::from_iter_values(
95 data.iter().map(|value| value.borrow().expiry),
96 )),
97 Arc::new(Int32Array::from_iter_values(
98 data.iter().map(|value| value.borrow().expiry_in_days),
99 )),
100 Arc::new(Float64Array::from_iter_values(
101 data.iter().map(|value| value.borrow().expiry_in_years),
102 )),
103 Arc::new(Float64Array::from_iter_values(
104 data.iter().map(|value| value.borrow().multiplier),
105 )),
106 Arc::new(Float64Array::from_iter_values(
107 data.iter().map(|value| value.borrow().quantity),
108 )),
109 Arc::new(Float64Array::from_iter_values(
110 data.iter().map(|value| value.borrow().underlying_price),
111 )),
112 Arc::new(Float64Array::from_iter_values(
113 data.iter().map(|value| value.borrow().interest_rate),
114 )),
115 Arc::new(Float64Array::from_iter_values(
116 data.iter().map(|value| value.borrow().cost_of_carry),
117 )),
118 Arc::new(Float64Array::from_iter_values(
119 data.iter().map(|value| value.borrow().vol),
120 )),
121 Arc::new(Float64Array::from_iter_values(
122 data.iter().map(|value| value.borrow().pnl),
123 )),
124 Arc::new(Float64Array::from_iter_values(
125 data.iter().map(|value| value.borrow().price),
126 )),
127 ];
128
129 columns.extend(greek_columns(
130 data.iter().map(|value| value.borrow().greeks),
131 ));
132 columns.push(Arc::new(Float64Array::from_iter_values(
133 data.iter().map(|value| value.borrow().itm_prob),
134 )));
135 record_batch_with_timestamps(Arc::new(Self::get_schema(Some(metadata.clone()))), columns)
136 }
137
138 fn metadata(&self) -> HashMap<String, String> {
139 metadata_with_type_name(Self::type_name_static(), None)
140 }
141}
142
143impl DecodeTypedFromRecordBatch for GreeksData {
144 fn decode_typed_batch(
145 _metadata: &HashMap<String, String>,
146 batch: RecordBatch,
147 ) -> Result<Vec<Self>, EncodingError> {
148 let batch = record_batch_with_u64_timestamps(&batch)?;
149 let ts_init = required_column::<UInt64Array>(&batch, "ts_init", DataType::UInt64)?;
150 let ts_event = required_column::<UInt64Array>(&batch, "ts_event", DataType::UInt64)?;
151 let instrument_id = required_string_column(&batch, "instrument_id")?;
152 let is_call = required_column::<BooleanArray>(&batch, "is_call", DataType::Boolean)?;
153 let strike = required_column::<Float64Array>(&batch, "strike", DataType::Float64)?;
154 let expiry = required_column::<Int32Array>(&batch, "expiry", DataType::Int32)?;
155 let expiry_in_days =
156 required_column::<Int32Array>(&batch, "expiry_in_days", DataType::Int32)?;
157 let expiry_in_years =
158 required_column::<Float64Array>(&batch, "expiry_in_years", DataType::Float64)?;
159 let multiplier = required_column::<Float64Array>(&batch, "multiplier", DataType::Float64)?;
160 let quantity = required_column::<Float64Array>(&batch, "quantity", DataType::Float64)?;
161 let underlying_price =
162 required_column::<Float64Array>(&batch, "underlying_price", DataType::Float64)?;
163 let interest_rate =
164 required_column::<Float64Array>(&batch, "interest_rate", DataType::Float64)?;
165 let cost_of_carry =
166 required_column::<Float64Array>(&batch, "cost_of_carry", DataType::Float64)?;
167 let vol = required_column::<Float64Array>(&batch, "vol", DataType::Float64)?;
168 let pnl = required_column::<Float64Array>(&batch, "pnl", DataType::Float64)?;
169 let price = required_column::<Float64Array>(&batch, "price", DataType::Float64)?;
170 let itm_prob = required_column::<Float64Array>(&batch, "itm_prob", DataType::Float64)?;
171 let greeks = decode_greeks(&batch)?;
172
173 (0..batch.num_rows())
174 .map(|row| {
175 Ok(Self {
176 instrument_id: instrument_id
177 .value(row)
178 .parse::<InstrumentId>()
179 .map_err(|e| EncodingError::ParseError("instrument_id", e.to_string()))?,
180 is_call: is_call.value(row),
181 strike: strike.value(row),
182 expiry: expiry.value(row),
183 expiry_in_days: expiry_in_days.value(row),
184 expiry_in_years: expiry_in_years.value(row),
185 multiplier: multiplier.value(row),
186 quantity: quantity.value(row),
187 underlying_price: underlying_price.value(row),
188 interest_rate: interest_rate.value(row),
189 cost_of_carry: cost_of_carry.value(row),
190 vol: vol.value(row),
191 pnl: pnl.value(row),
192 price: price.value(row),
193 greeks: greeks[row],
194 itm_prob: itm_prob.value(row),
195 ts_event: ts_event.value(row).into(),
196 ts_init: ts_init.value(row).into(),
197 })
198 })
199 .collect()
200 }
201}
202
203impl ArrowSchemaProvider for PortfolioGreeks {
204 fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
205 let mut fields = vec![
206 Field::new("ts_init", timestamp_data_type(), false),
207 Field::new("ts_event", timestamp_data_type(), false),
208 Field::new("pnl", DataType::Float64, false),
209 Field::new("price", DataType::Float64, false),
210 ];
211
212 fields.extend(greek_fields());
213 Schema::new_with_metadata(fields, metadata_with_type_name("PortfolioGreeks", metadata))
214 }
215}
216
217impl EncodeToRecordBatch for PortfolioGreeks {
218 fn encode_batch<T: Borrow<Self>>(
219 metadata: &HashMap<String, String>,
220 data: &[T],
221 ) -> Result<RecordBatch, ArrowError> {
222 let mut columns: Vec<ArrayRef> = vec![
223 Arc::new(UInt64Array::from_iter_values(
224 data.iter().map(|value| value.borrow().ts_init.as_u64()),
225 )),
226 Arc::new(UInt64Array::from_iter_values(
227 data.iter().map(|value| value.borrow().ts_event.as_u64()),
228 )),
229 Arc::new(Float64Array::from_iter_values(
230 data.iter().map(|value| value.borrow().pnl),
231 )),
232 Arc::new(Float64Array::from_iter_values(
233 data.iter().map(|value| value.borrow().price),
234 )),
235 ];
236
237 columns.extend(greek_columns(
238 data.iter().map(|value| value.borrow().greeks),
239 ));
240 record_batch_with_timestamps(Arc::new(Self::get_schema(Some(metadata.clone()))), columns)
241 }
242
243 fn metadata(&self) -> HashMap<String, String> {
244 metadata_with_type_name("PortfolioGreeks", None)
245 }
246}
247
248impl DecodeTypedFromRecordBatch for PortfolioGreeks {
249 fn decode_typed_batch(
250 _metadata: &HashMap<String, String>,
251 batch: RecordBatch,
252 ) -> Result<Vec<Self>, EncodingError> {
253 let batch = record_batch_with_u64_timestamps(&batch)?;
254 let ts_init = required_column::<UInt64Array>(&batch, "ts_init", DataType::UInt64)?;
255 let ts_event = required_column::<UInt64Array>(&batch, "ts_event", DataType::UInt64)?;
256 let pnl = required_column::<Float64Array>(&batch, "pnl", DataType::Float64)?;
257 let price = required_column::<Float64Array>(&batch, "price", DataType::Float64)?;
258 let greeks = decode_greeks(&batch)?;
259
260 (0..batch.num_rows())
261 .map(|row| {
262 Ok(Self {
263 pnl: pnl.value(row),
264 price: price.value(row),
265 greeks: greeks[row],
266 ts_event: ts_event.value(row).into(),
267 ts_init: ts_init.value(row).into(),
268 })
269 })
270 .collect()
271 }
272}
273
274impl ArrowSchemaProvider for YieldCurve {
275 fn get_schema(metadata: Option<HashMap<String, String>>) -> Schema {
276 let fields = vec![
277 Field::new("ts_init", timestamp_data_type(), false),
278 Field::new("ts_event", timestamp_data_type(), false),
279 Field::new("curve_name", DataType::Utf8, false),
280 Field::new("tenors", float_list_data_type(), false),
281 Field::new("interest_rates", float_list_data_type(), false),
282 ];
283 Schema::new_with_metadata(
284 fields,
285 metadata_with_type_name(Self::type_name_static(), metadata),
286 )
287 }
288}
289
290impl EncodeToRecordBatch for YieldCurve {
291 fn encode_batch<T: Borrow<Self>>(
292 metadata: &HashMap<String, String>,
293 data: &[T],
294 ) -> Result<RecordBatch, ArrowError> {
295 let columns: Vec<ArrayRef> = vec![
296 Arc::new(UInt64Array::from_iter_values(
297 data.iter().map(|value| value.borrow().ts_init.as_u64()),
298 )),
299 Arc::new(UInt64Array::from_iter_values(
300 data.iter().map(|value| value.borrow().ts_event.as_u64()),
301 )),
302 Arc::new(StringArray::from_iter_values(
303 data.iter().map(|value| value.borrow().curve_name.as_str()),
304 )),
305 Arc::new(float_lists(
306 data.iter().map(|value| value.borrow().tenors.as_slice()),
307 )),
308 Arc::new(float_lists(
309 data.iter()
310 .map(|value| value.borrow().interest_rates.as_slice()),
311 )),
312 ];
313 record_batch_with_timestamps(Arc::new(Self::get_schema(Some(metadata.clone()))), columns)
314 }
315
316 fn metadata(&self) -> HashMap<String, String> {
317 metadata_with_type_name(Self::type_name_static(), None)
318 }
319}
320
321impl DecodeTypedFromRecordBatch for YieldCurve {
322 fn decode_typed_batch(
323 _metadata: &HashMap<String, String>,
324 batch: RecordBatch,
325 ) -> Result<Vec<Self>, EncodingError> {
326 let batch = record_batch_with_u64_timestamps(&batch)?;
327 let ts_init = required_column::<UInt64Array>(&batch, "ts_init", DataType::UInt64)?;
328 let ts_event = required_column::<UInt64Array>(&batch, "ts_event", DataType::UInt64)?;
329 let curve_name = required_string_column(&batch, "curve_name")?;
330 let tenors = required_column::<ListArray>(&batch, "tenors", float_list_data_type())?;
331 let interest_rates =
332 required_column::<ListArray>(&batch, "interest_rates", float_list_data_type())?;
333 (0..batch.num_rows())
334 .map(|row| {
335 Ok(Self {
336 curve_name: curve_name.value(row).to_string(),
337 tenors: decode_float_list(tenors, "tenors", row)?,
338 interest_rates: decode_float_list(interest_rates, "interest_rates", row)?,
339 ts_event: ts_event.value(row).into(),
340 ts_init: ts_init.value(row).into(),
341 })
342 })
343 .collect()
344 }
345}
346
347macro_rules! impl_greeks_custom_data_decode {
348 ($($type:ident),+ $(,)?) => {
349 $(
350 impl DecodeDataFromRecordBatch for $type {
351 fn decode_data_batch(
352 metadata: &HashMap<String, String>,
353 record_batch: RecordBatch,
354 ) -> Result<Vec<Data>, EncodingError> {
355 Ok(Self::decode_typed_batch(metadata, record_batch)?
356 .into_iter()
357 .map(|data| Data::Custom(CustomData::from_arc(Arc::new(data))))
358 .collect())
359 }
360 }
361 )+
362 };
363}
364impl_greeks_custom_data_decode!(GreeksData, PortfolioGreeks, YieldCurve);
365
366fn greek_fields() -> Vec<Field> {
367 ["delta", "gamma", "vega", "theta", "rho"]
368 .into_iter()
369 .map(|name| Field::new(name, DataType::Float64, false))
370 .collect()
371}
372
373fn greek_columns(values: impl Iterator<Item = OptionGreekValues> + Clone) -> Vec<ArrayRef> {
374 vec![
375 Arc::new(Float64Array::from_iter_values(
376 values.clone().map(|value| value.delta),
377 )),
378 Arc::new(Float64Array::from_iter_values(
379 values.clone().map(|value| value.gamma),
380 )),
381 Arc::new(Float64Array::from_iter_values(
382 values.clone().map(|value| value.vega),
383 )),
384 Arc::new(Float64Array::from_iter_values(
385 values.clone().map(|value| value.theta),
386 )),
387 Arc::new(Float64Array::from_iter_values(
388 values.map(|value| value.rho),
389 )),
390 ]
391}
392
393fn decode_greeks(batch: &RecordBatch) -> Result<Vec<OptionGreekValues>, EncodingError> {
394 let delta = required_column::<Float64Array>(batch, "delta", DataType::Float64)?;
395 let gamma = required_column::<Float64Array>(batch, "gamma", DataType::Float64)?;
396 let vega = required_column::<Float64Array>(batch, "vega", DataType::Float64)?;
397 let theta = required_column::<Float64Array>(batch, "theta", DataType::Float64)?;
398 let rho = required_column::<Float64Array>(batch, "rho", DataType::Float64)?;
399 Ok((0..batch.num_rows())
400 .map(|row| OptionGreekValues {
401 delta: delta.value(row),
402 gamma: gamma.value(row),
403 vega: vega.value(row),
404 theta: theta.value(row),
405 rho: rho.value(row),
406 })
407 .collect())
408}
409
410fn required_column<'a, A: Array + 'static>(
411 batch: &'a RecordBatch,
412 name: &'static str,
413 data_type: DataType,
414) -> Result<&'a A, EncodingError> {
415 let column = extract_column_by_name::<A>(batch, name, data_type)?;
416
417 if column.null_count() != 0 {
418 return Err(EncodingError::ParseError(
419 name,
420 "required column contains nulls".to_string(),
421 ));
422 }
423
424 Ok(column)
425}
426
427fn required_string_column<'a>(
428 batch: &'a RecordBatch,
429 name: &'static str,
430) -> Result<StringColumnRef<'a>, EncodingError> {
431 let index = batch.schema().index_of(name)?;
432 let column = extract_column_string(batch.columns(), name, index)?;
433
434 if batch.column(index).logical_null_count() != 0 {
435 return Err(EncodingError::ParseError(
436 name,
437 "required column contains nulls".to_string(),
438 ));
439 }
440
441 Ok(column)
442}
443
444fn float_list_data_type() -> DataType {
445 DataType::List(Arc::new(Field::new("item", DataType::Float64, true)))
446}
447
448fn float_lists<'a>(values: impl Iterator<Item = &'a [f64]>) -> ListArray {
449 let mut builder = ListBuilder::new(Float64Builder::new());
450 for values in values {
451 builder.values().append_slice(values);
452 builder.append(true);
453 }
454
455 builder.finish()
456}
457
458fn decode_float_list(
459 values: &ListArray,
460 name: &'static str,
461 row: usize,
462) -> Result<Vec<f64>, EncodingError> {
463 let values = values.value(row);
464
465 let values = values
466 .as_any()
467 .downcast_ref::<Float64Array>()
468 .ok_or_else(|| {
469 EncodingError::ParseError(name, "expected Float64 list values".to_string())
470 })?;
471
472 if values.null_count() != 0 {
473 return Err(EncodingError::ParseError(
474 name,
475 format!("row {row}: list contains nulls"),
476 ));
477 }
478
479 Ok(values.values().to_vec())
480}
481
482#[cfg(test)]
483mod tests {
484 use nautilus_model::data::{decode_custom_from_arrow, encode_custom_to_arrow};
485 use rstest::rstest;
486
487 use super::*;
488 use crate::arrow::KEY_TYPE_NAME;
489
490 fn sensitivities() -> OptionGreekValues {
491 OptionGreekValues {
492 delta: 0.41,
493 gamma: 0.0012,
494 vega: 11.2,
495 theta: -2.3,
496 rho: 1.7,
497 }
498 }
499
500 fn assert_sensitivities(actual: OptionGreekValues, expected: OptionGreekValues) {
501 assert_eq!(actual.delta.to_bits(), expected.delta.to_bits());
502 assert_eq!(actual.gamma.to_bits(), expected.gamma.to_bits());
503 assert_eq!(actual.vega.to_bits(), expected.vega.to_bits());
504 assert_eq!(actual.theta.to_bits(), expected.theta.to_bits());
505 assert_eq!(actual.rho.to_bits(), expected.rho.to_bits());
506 }
507
508 #[rstest]
509 fn test_greeks_data_round_trip() {
510 let first = GreeksData::new(
511 "ESZ26 C7000.XCME".parse().unwrap(),
512 false,
513 7000.5,
514 20_261_218,
515 -68,
516 0.186,
517 50.0,
518 -3.0,
519 6950.25,
520 0.0425,
521 0.0125,
522 0.175,
523 12.5,
524 98.75,
525 sensitivities(),
526 0.62,
527 11.into(),
528 13.into(),
529 );
530 let mut second = first.clone();
531 second.instrument_id = "ESZ26 P6900.XCME".parse().unwrap();
532 second.is_call = true;
533 second.ts_init = 31.into();
534 second.ts_event = 29.into();
535 second.greeks.rho = -0.0;
536 second.greeks.delta = f64::from_bits(0x3fe0_0000_0000_0001);
537 let values = [first, second];
538 let batch = GreeksData::encode_batch(&values[0].metadata(), &values).unwrap();
539 let decoded =
540 GreeksData::decode_typed_batch(batch.schema().metadata(), batch.clone()).unwrap();
541
542 assert_eq!(
543 batch
544 .schema()
545 .field_with_name("expiry")
546 .unwrap()
547 .data_type(),
548 &DataType::Int32
549 );
550 assert_eq!(
551 batch.schema().field_with_name("rho").unwrap().data_type(),
552 &DataType::Float64
553 );
554 assert_eq!(decoded.len(), values.len());
555
556 for (actual, expected) in decoded.iter().zip(&values) {
557 assert_eq!(actual.instrument_id, expected.instrument_id);
558 assert_eq!(actual.is_call, expected.is_call);
559 assert_eq!(actual.expiry, expected.expiry);
560 assert_eq!(actual.expiry_in_days, expected.expiry_in_days);
561 assert_eq!(actual.ts_init, expected.ts_init);
562 assert_eq!(actual.ts_event, expected.ts_event);
563 macro_rules! assert_float { ($($field:ident),+) => { $(assert_eq!(actual.$field.to_bits(), expected.$field.to_bits(), stringify!($field));)+ }; }
564 assert_float!(
565 strike,
566 expiry_in_years,
567 multiplier,
568 quantity,
569 underlying_price,
570 interest_rate,
571 cost_of_carry,
572 vol,
573 pnl,
574 price,
575 itm_prob
576 );
577 assert_sensitivities(actual.greeks, expected.greeks);
578 }
579 }
580
581 #[rstest]
582 fn test_portfolio_greeks_round_trip() {
583 let values = [PortfolioGreeks {
584 pnl: -125.5,
585 price: 4310.25,
586 greeks: sensitivities(),
587 ts_event: 19.into(),
588 ts_init: 17.into(),
589 }];
590
591 let batch = PortfolioGreeks::encode_batch(&values[0].metadata(), &values).unwrap();
592 let decoded =
593 PortfolioGreeks::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
594
595 assert_eq!(decoded.len(), values.len());
596 assert_eq!(decoded[0].ts_init, values[0].ts_init);
597 assert_eq!(decoded[0].ts_event, values[0].ts_event);
598 assert_eq!(decoded[0].pnl.to_bits(), values[0].pnl.to_bits());
599 assert_eq!(decoded[0].price.to_bits(), values[0].price.to_bits());
600 assert_sensitivities(decoded[0].greeks, values[0].greeks);
601 }
602
603 #[rstest]
604 #[case::instrument(Arc::new(GreeksData::from_delta(
605 "ES.GLBX".parse().unwrap(), 1.25, 8.0, 11.into(),
606 )))]
607 #[case::portfolio(Arc::new(PortfolioGreeks {
608 pnl: -125.5,
609 price: 4310.25,
610 greeks: sensitivities(),
611 ts_event: 19.into(),
612 ts_init: 17.into(),
613 }))]
614 #[case::yield_curve(Arc::new(YieldCurve::new(
615 "USD-SOFR".to_string(),
616 vec![0.25, 1.0, 5.0],
617 vec![0.043, 0.041, 0.038],
618 23.into(),
619 29.into(),
620 )))]
621 fn test_greeks_registered_custom_data_round_trip(#[case] item: Arc<dyn CustomDataTrait>) {
622 crate::ensure_custom_data_registered::<GreeksData>();
623 crate::ensure_custom_data_registered::<PortfolioGreeks>();
624 crate::ensure_custom_data_registered::<YieldCurve>();
625 let type_name = item.type_name();
626
627 let batch = encode_custom_to_arrow(type_name, std::slice::from_ref(&item))
628 .unwrap()
629 .unwrap();
630 let metadata = batch.schema().metadata().clone();
631 let decoded = decode_custom_from_arrow(type_name, &metadata, batch)
632 .unwrap()
633 .unwrap();
634
635 let [Data::Custom(custom)] = decoded.as_slice() else {
636 panic!("expected one custom data row, was {decoded:?}");
637 };
638
639 assert_eq!(custom.data_type.type_name(), type_name);
640 assert_eq!(
641 metadata,
642 HashMap::from([(KEY_TYPE_NAME.to_string(), type_name.to_string())]),
643 );
644 assert!(custom.data.eq_arc(item.as_ref()));
645 }
646
647 #[rstest]
648 #[case(vec![0.25, 1.0, 5.0], vec![0.043, 0.041, 0.038])]
649 #[case(vec![], vec![-0.0, f64::from_bits(0x3fe0_0000_0000_0001)])]
650 fn test_yield_curve_round_trip(#[case] tenors: Vec<f64>, #[case] interest_rates: Vec<f64>) {
651 let curve = YieldCurve::new(
652 "USD-SOFR".to_string(),
653 tenors,
654 interest_rates,
655 23.into(),
656 29.into(),
657 );
658 let batch =
659 YieldCurve::encode_batch(&curve.metadata(), std::slice::from_ref(&curve)).unwrap();
660 let decoded = YieldCurve::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
661
662 assert_eq!(decoded.len(), 1);
663 assert_eq!(decoded[0].ts_init, curve.ts_init);
664 assert_eq!(decoded[0].ts_event, curve.ts_event);
665 assert_eq!(decoded[0].curve_name, curve.curve_name);
666 assert_eq!(
667 decoded[0]
668 .tenors
669 .iter()
670 .map(|v| v.to_bits())
671 .collect::<Vec<_>>(),
672 curve.tenors.iter().map(|v| v.to_bits()).collect::<Vec<_>>()
673 );
674 assert_eq!(
675 decoded[0]
676 .interest_rates
677 .iter()
678 .map(|v| v.to_bits())
679 .collect::<Vec<_>>(),
680 curve
681 .interest_rates
682 .iter()
683 .map(|v| v.to_bits())
684 .collect::<Vec<_>>()
685 );
686 }
687
688 #[rstest]
689 fn test_native_greeks_empty_batches() {
690 macro_rules! assert_empty {
691 ($type:ty) => {{
692 let batch = <$type>::encode_batch(&HashMap::new(), &Vec::<$type>::new()).unwrap();
693 let decoded =
694 <$type>::decode_typed_batch(batch.schema().metadata(), batch).unwrap();
695 assert!(decoded.is_empty());
696 }};
697 }
698 assert_empty!(GreeksData);
699 assert_empty!(PortfolioGreeks);
700 assert_empty!(YieldCurve);
701 }
702
703 #[rstest]
704 #[case("pnl")]
705 #[case("rho")]
706 fn test_portfolio_greeks_rejects_null_values(#[case] name: &'static str) {
707 let value = PortfolioGreeks {
708 pnl: -125.5,
709 price: 4310.25,
710 greeks: sensitivities(),
711 ts_event: 19.into(),
712 ts_init: 17.into(),
713 };
714
715 let batch = PortfolioGreeks::encode_batch(&value.metadata(), &[value]).unwrap();
716 let index = batch.schema().index_of(name).unwrap();
717 let mut fields = batch.schema().fields().to_vec();
718 fields[index] = Arc::new(fields[index].as_ref().clone().with_nullable(true));
719 let mut columns = batch.columns().to_vec();
720 columns[index] = Arc::new(Float64Array::from(vec![None::<f64>]));
721 let batch = RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap();
722 let error = PortfolioGreeks::decode_typed_batch(&HashMap::new(), batch).unwrap_err();
723
724 assert!(
725 matches!(error, EncodingError::ParseError(field, ref message)
726 if field == name && message == "required column contains nulls")
727 );
728 }
729
730 #[rstest]
731 #[case(Some("USD-SOFR"))]
732 #[case(None)]
733 fn test_yield_curve_dictionary_name(#[case] name: Option<&str>) {
734 use arrow::{
735 array::{DictionaryArray, Int8Array},
736 datatypes::Int8Type,
737 };
738
739 let value = YieldCurve::new(
740 "USD-SOFR".to_string(),
741 vec![0.25],
742 vec![0.043],
743 23.into(),
744 29.into(),
745 );
746 let batch = YieldCurve::encode_batch(&value.metadata(), &[value]).unwrap();
747 let index = batch.schema().index_of("curve_name").unwrap();
748 let names = DictionaryArray::<Int8Type>::try_new(
749 Int8Array::from(vec![0]),
750 Arc::new(StringArray::from(vec![name])),
751 )
752 .unwrap();
753 let mut fields = batch.schema().fields().to_vec();
754 fields[index] = Arc::new(Field::new("curve_name", names.data_type().clone(), true));
755 let mut columns = batch.columns().to_vec();
756 columns[index] = Arc::new(names);
757 let batch = RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap();
758 let decoded = YieldCurve::decode_typed_batch(&HashMap::new(), batch);
759
760 match name {
761 Some(name) => assert_eq!(decoded.unwrap()[0].curve_name, name),
762 None => assert!(
763 matches!(decoded.unwrap_err(), EncodingError::ParseError("curve_name", ref message) if message == "required column contains nulls")
764 ),
765 }
766 }
767
768 #[rstest]
769 #[case("curve_name")]
770 #[case("tenors")]
771 #[case("interest_rates")]
772 fn test_yield_curve_rejects_null_values(#[case] name: &'static str) {
773 let value = YieldCurve::new(
774 "USD-SOFR".to_string(),
775 vec![0.25],
776 vec![0.043],
777 23.into(),
778 29.into(),
779 );
780 let batch = YieldCurve::encode_batch(&value.metadata(), &[value]).unwrap();
781 let index = batch.schema().index_of(name).unwrap();
782 let mut fields = batch.schema().fields().to_vec();
783 let mut columns = batch.columns().to_vec();
784
785 let expected = if name == "curve_name" {
786 fields[index] = Arc::new(fields[index].as_ref().clone().with_nullable(true));
787 columns[index] = Arc::new(StringArray::from(vec![None::<&str>]));
788 "required column contains nulls"
789 } else {
790 let mut builder = ListBuilder::new(Float64Builder::new());
791 builder.values().append_null();
792 builder.append(true);
793 columns[index] = Arc::new(builder.finish());
794 "row 0: list contains nulls"
795 };
796
797 let batch = RecordBatch::try_new(Arc::new(Schema::new(fields)), columns).unwrap();
798 let error = YieldCurve::decode_typed_batch(&HashMap::new(), batch).unwrap_err();
799
800 assert!(
801 matches!(error, EncodingError::ParseError(field, ref message)
802 if field == name && message == expected)
803 );
804 }
805}