finql 0.12.0

A quantitative finance toolbox
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use crate::datatypes::Transaction;
use chrono::{Datelike, Local, NaiveDate};
use serde::{Deserialize, Serialize};
use std::default::Default;
use std::fmt::Display;
use thiserror::Error;

#[derive(Error, Debug)]
pub enum PeriodDateError {
    #[error("Fixed date is chosen but no date is given")]
    MissingFixedDate,
    #[error("Unknown period date type")]
    UnknownPeriodDateType,
    #[error("Cannot deduce inception date")]
    MissingInceptionDate,
}

/// Period start or end date
#[derive(Debug, Clone, Copy, Serialize, Deserialize)]
pub enum PeriodDate {
    Inception,
    Today,
    FirstOfMonth,
    FirstOfYear,
    FixedDate(NaiveDate),
}

impl Display for PeriodDate {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            PeriodDate::Inception => write!(f, "Inception"),
            PeriodDate::Today => write!(f, "Today"),
            PeriodDate::FirstOfMonth => write!(f, "FirstOfMonth"),
            PeriodDate::FirstOfYear => write!(f, "FirstOfYear"),
            PeriodDate::FixedDate(_) => write!(f, "FixedDate"),
        }
    }
}

impl Default for PeriodDate {
    fn default() -> PeriodDate {
        PeriodDate::Today
    }
}

impl PeriodDate {
    pub fn new(date_type: &str, date: Option<NaiveDate>) -> Result<PeriodDate, PeriodDateError> {
        match date_type {
            "Inception" => Ok(PeriodDate::Inception),
            "Today" => Ok(PeriodDate::Today),
            "FirstOfMonth" => Ok(PeriodDate::FirstOfMonth),
            "FirstOfYear" => Ok(PeriodDate::FirstOfYear),
            "FixedDate" => {
                if let Some(date) = date {
                    Ok(PeriodDate::FixedDate(date))
                } else {
                    Err(PeriodDateError::MissingFixedDate)
                }
            }
            _ => Err(PeriodDateError::UnknownPeriodDateType),
        }
    }

    pub fn date(&self, inception: Option<NaiveDate>) -> Result<NaiveDate, PeriodDateError> {
        match self {
            PeriodDate::Today => Ok(Local::today().naive_local()),
            PeriodDate::FirstOfMonth => {
                let today = Local::today().naive_local();
                Ok(NaiveDate::from_ymd(today.year(), today.month(), 1))
            }
            PeriodDate::FirstOfYear => {
                let today = Local::today().naive_local();
                Ok(NaiveDate::from_ymd(today.year(), 1, 1))
            }
            PeriodDate::FixedDate(date) => Ok(*date),
            PeriodDate::Inception => inception.ok_or(PeriodDateError::MissingInceptionDate),
        }
    }

    pub fn date_from_trades(&self, trades: &[Transaction]) -> Result<NaiveDate, PeriodDateError> {
        let inception = trades.iter().map(|t| t.cash_flow.date).min();
        self.date(inception)
    }
}