finance-portfolio 0.1.0

Standard financial portfolio tools
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
125
126
127
128
129
130
131
132

use pyo3::prelude::*;

mod example;

pub use example::Example;

fn map_err(error: String) -> PyErr {
    pyo3::exceptions::PyValueError::new_err(error)
}

#[pyfunction]
fn equal_weights(count: usize) -> PyResult<Vec<f64>> {
    ::finance_portfolio::equal_weights(count).map_err(map_err)
}

#[pyfunction]
fn rank_weights(values: Vec<f64>, ascending: bool) -> PyResult<Vec<f64>> {
    ::finance_portfolio::rank_weights(values, ascending).map_err(map_err)
}

#[pyfunction]
fn signal_proportional_weights(values: Vec<f64>) -> PyResult<Vec<f64>> {
    ::finance_portfolio::signal_proportional_weights(values).map_err(map_err)
}

#[pyfunction]
fn target_volatility_weights(volatility: Vec<f64>) -> PyResult<Vec<f64>> {
    ::finance_portfolio::target_volatility_weights(volatility).map_err(map_err)
}

#[pyfunction]
fn minimum_variance_weights(covariance: Vec<Vec<f64>>) -> PyResult<Vec<f64>> {
    ::finance_portfolio::minimum_variance_weights(covariance).map_err(map_err)
}

#[pyfunction]
fn mean_variance_weights(
    expected_returns: Vec<f64>,
    covariance: Vec<Vec<f64>>,
    risk_aversion: f64,
) -> PyResult<Vec<f64>> {
    ::finance_portfolio::mean_variance_weights(expected_returns, covariance, risk_aversion)
        .map_err(map_err)
}

#[pyfunction]
fn risk_parity_weights(
    covariance: Vec<Vec<f64>>,
    max_iter: usize,
    tolerance: f64,
) -> PyResult<Vec<f64>> {
    ::finance_portfolio::risk_parity_weights(covariance, max_iter, tolerance).map_err(map_err)
}

#[pyfunction]
fn hierarchical_risk_parity_weights(covariance: Vec<Vec<f64>>) -> PyResult<Vec<f64>> {
    ::finance_portfolio::hierarchical_risk_parity_weights(covariance).map_err(map_err)
}

#[pyfunction]
fn portfolio_variance(weights: Vec<f64>, covariance: Vec<Vec<f64>>) -> PyResult<f64> {
    ::finance_portfolio::portfolio_variance(weights, covariance).map_err(map_err)
}

#[pyfunction]
fn portfolio_volatility(weights: Vec<f64>, covariance: Vec<Vec<f64>>) -> PyResult<f64> {
    ::finance_portfolio::portfolio_volatility(weights, covariance).map_err(map_err)
}

#[pyfunction]
fn risk_contribution(
    weights: Vec<f64>,
    covariance: Vec<Vec<f64>>,
) -> PyResult<(Vec<f64>, Vec<f64>, Vec<f64>)> {
    ::finance_portfolio::risk_contribution(weights, covariance).map_err(map_err)
}

#[pyfunction]
fn tracking_error(active_weights: Vec<f64>, covariance: Vec<Vec<f64>>) -> PyResult<f64> {
    ::finance_portfolio::tracking_error(active_weights, covariance).map_err(map_err)
}

#[pyfunction]
fn active_share(active_weights: Vec<f64>) -> f64 {
    ::finance_portfolio::active_share(active_weights)
}

#[pyfunction]
fn brinson_attribution(
    portfolio_weights: Vec<f64>,
    benchmark_weights: Vec<f64>,
    portfolio_returns: Vec<f64>,
    benchmark_returns: Vec<f64>,
) -> PyResult<(f64, f64, f64, f64)> {
    ::finance_portfolio::brinson_attribution(
        portfolio_weights,
        benchmark_weights,
        portfolio_returns,
        benchmark_returns,
    )
    .map_err(map_err)
}

#[pyfunction]
fn factor_return_decomposition(
    exposures: Vec<f64>,
    factor_returns: Vec<f64>,
) -> PyResult<(Vec<f64>, f64)> {
    ::finance_portfolio::factor_return_decomposition(exposures, factor_returns).map_err(map_err)
}

#[pymodule]
fn finance_portfolio(_py: Python, m: &Bound<PyModule>) -> PyResult<()> {
    // Example
    m.add_class::<Example>().unwrap();
    m.add_function(wrap_pyfunction!(equal_weights, m)?)?;
    m.add_function(wrap_pyfunction!(rank_weights, m)?)?;
    m.add_function(wrap_pyfunction!(signal_proportional_weights, m)?)?;
    m.add_function(wrap_pyfunction!(target_volatility_weights, m)?)?;
    m.add_function(wrap_pyfunction!(minimum_variance_weights, m)?)?;
    m.add_function(wrap_pyfunction!(mean_variance_weights, m)?)?;
    m.add_function(wrap_pyfunction!(risk_parity_weights, m)?)?;
    m.add_function(wrap_pyfunction!(hierarchical_risk_parity_weights, m)?)?;
    m.add_function(wrap_pyfunction!(portfolio_variance, m)?)?;
    m.add_function(wrap_pyfunction!(portfolio_volatility, m)?)?;
    m.add_function(wrap_pyfunction!(risk_contribution, m)?)?;
    m.add_function(wrap_pyfunction!(tracking_error, m)?)?;
    m.add_function(wrap_pyfunction!(active_share, m)?)?;
    m.add_function(wrap_pyfunction!(brinson_attribution, m)?)?;
    m.add_function(wrap_pyfunction!(factor_return_decomposition, m)?)?;
    Ok(())
}