stochastic-rs-copulas 2.0.0-rc.1

Bivariate, multivariate, and empirical copulas.
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

//! # Independence
//!
//! $$
//! C(u,v)=uv
//! $$
//!
use std::error::Error;

use ndarray::Array1;
use ndarray::Array2;
use ndarray::Axis;
use ndarray::stack;
use stochastic_rs_distributions::uniform::SimdUniform;

use super::CopulaType;
use crate::traits::BivariateExt;

#[derive(Debug, Clone)]
pub struct Independence {
  pub r#type: CopulaType,
  pub theta: Option<f64>,
  pub tau: Option<f64>,
  pub theta_bounds: (f64, f64),
  pub invalid_thetas: Vec<f64>,
}

impl Default for Independence {
  fn default() -> Self {
    Self {
      r#type: CopulaType::Independence,
      theta: None,
      tau: None,
      theta_bounds: (0.0, 0.0),
      invalid_thetas: vec![],
    }
  }
}

impl Independence {
  pub fn new() -> Self {
    Self::default()
  }
}

impl BivariateExt for Independence {
  fn r#type(&self) -> CopulaType {
    self.r#type
  }

  fn tau(&self) -> Option<f64> {
    self.tau
  }

  fn set_tau(&mut self, tau: f64) {
    self.tau = Some(tau);
  }

  fn theta(&self) -> Option<f64> {
    self.theta
  }

  fn theta_bounds(&self) -> (f64, f64) {
    self.theta_bounds
  }

  fn invalid_thetas(&self) -> Vec<f64> {
    self.invalid_thetas.clone()
  }

  fn set_theta(&mut self, theta: f64) {
    self.theta = Some(theta);
  }

  fn fit(&mut self, _X: &Array2<f64>) -> Result<(), Box<dyn Error>> {
    self.tau = Some(0.0);
    self.theta = Some(0.0);
    Ok(())
  }

  fn sample(&mut self, n: usize) -> Result<Array2<f64>, Box<dyn Error>> {
    let ud = SimdUniform::<f64>::new(0.0, 1.0);
    let u = Array1::from_vec((0..n).map(|_| ud.sample_fast()).collect());
    let v = Array1::from_vec((0..n).map(|_| ud.sample_fast()).collect());
    Ok(stack![Axis(1), u, v])
  }

  fn generator(&self, t: &Array1<f64>) -> Result<Array1<f64>, Box<dyn Error>> {
    Ok(t.ln())
  }

  fn pdf(&self, X: &Array2<f64>) -> Result<Array1<f64>, Box<dyn Error>> {
    let in_range = X.map_axis(Axis(1), |row| {
      row.iter().all(|&val| (0.0..=1.0).contains(&val))
    });

    let out = in_range.map(|&val| if val { 1.0 } else { 0.0 });

    Ok(out)
  }

  fn cdf(&self, X: &Array2<f64>) -> Result<Array1<f64>, Box<dyn Error>> {
    let U = X.column(0);
    let V = X.column(1);

    Ok(&U * &V)
  }

  fn partial_derivative(&self, X: &Array2<f64>) -> Result<Array1<f64>, Box<dyn std::error::Error>> {
    let V = X.column(1);
    Ok(V.to_owned())
  }

  fn percent_point(
    &self,
    y: &Array1<f64>,
    _V: &Array1<f64>,
  ) -> Result<Array1<f64>, Box<dyn Error>> {
    Ok(y.to_owned())
  }

  fn compute_theta(&self) -> f64 {
    0.0
  }
}