Implement a Curve type.

[avhz]

A Curve type could represent a yield curve or discount curve, or volatility term structure, for example.

[Aditya-dom]

A Curve type could represent a yield curve or discount curve, or volatility term structure, for example.

Hi @avhz, could you please let me know if you're currently addressing this issue? If not, I would be happy to take on the task.

[avhz]

@Autoparallel were you looking at this?

[Autoparallel]

@Autoparallel were you looking at this?

I was but got busy with other work

[avhz]

@Autoparallel yeah no worries, just checking.
@Aditya-dom you might want to discuss with @Autoparallel here.

[Aditya-dom]

@Autoparallel yeah no worries, just checking. @Aditya-dom you might want to discuss with @Autoparallel here.

Yup!! Thank you @avhz

[Aditya-dom]

Hello @Autoparallel, Is there anything in this topic that I can help you with?

[Aditya-dom]

Creating a Curve trait with required methods:

pub trait Curve {
    type Point;

    fn new() -> Self;
    fn points(&self) -> Vec<Self::Point>;

    fn interpolate(&self, index: usize, fraction: f64) -> 
Option<Self::Point>;
}

Next, let's define a YieldCurve struct that conforms to the Curve
trait and represents a yield curve:

#[derive(Debug, Clone)]
pub struct YieldCurve {
    points: Vec<(DateTime<Utc>, f64)> // Date and yield
}

impl Curve for YieldCurve {
    type Point = (DateTime<Utc>, f64);

    fn new() -> Self {
        YieldCurve::default()
    }

    fn points(&self) -> Vec<Self::Point> {
        self.points.clone()
    }

    fn interpolate(&self, index: usize, fraction: f64) -> 
Option<Self::Point> {
        if index < self.points.len() && index >= 0 {
            let point = &self.points[index];
            Some((point.0 + chrono::Duration::seconds(f64::from(index as 
i32 * (self.steps()))), interpolate_yield(*point, 
*(self.points.get(index+1).map_or(None, |p| p.1)), fraction)))
        } else {
            None
        }
    }
}

fn interpolate_yield(prev: (DateTime<Utc>, f64), next: Option<f64>, 
fraction: f64) -> f64 {
    match next {
        Some(next_yield) => prev.1 + ((next_yield - prev.1) * fraction),
        None => prev.1,
    }
}

In the example above, YieldCurve stores dates and yields in a vector of
tuples. The new() method initializes an empty YieldCurve. The
points() method returns a clone of the stored points vector. The
interpolate() method checks the index and interpolates a yield between
two points based on the given fraction.

We can extend this code snippet to add more functionality or create other
curve types, such as DiscountCurve or VolatilityCurve, by implementing the
required Curve trait methods accordingly.

@avhz , @Autoparallel Hello! I've prepared a prototype for curve and I'm excited about its potential. Would you be so kind as to grant me permission to proceed with the full implementation? Your support would mean a lot to me. Thank you!