cutup 0.1.4

A flexible and efficient allocation library for Rust, capable of distributing assets, resources, and other divisible entities.
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

# Cutup: A Rust Portfolio Allocation Library

[![Crates.io](https://img.shields.io/crates/v/cutup)](https://crates.io/crates/cutup)
[![Build Status](https://github.com/thinkjrs/cutup/actions/workflows/tests.yml/badge.svg)](https://github.com/thinkjrs/cutup/actions/workflows/tests.yml)
[![codecov](https://codecov.io/gh/thinkjrs/cutup/branch/main/graph/badge.svg)](https://codecov.io/gh/thinkjrs/cutup)
[![Docs.rs](https://docs.rs/cutup/badge.svg)](https://docs.rs/cutup)
[![License](https://img.shields.io/crates/l/cutup)](https://crates.io/crates/cutup)

Cutup is a Rust library for portfolio allocation strategies, providing implementations for various allocation methods. 

It's designed to be efficient and easy to use.

Here are some of the allocation methods included in this library:

- **Mean-Variance Optimization (MVO)**
- **Equal Weight Allocation (EW)**
- **Hierarchical Risk Parity (HRP)**

This library leverages `nalgebra` for efficient matrix operations and is designed for performance and extensibility.

## Features

- **MVO Allocation**: Computes portfolio weights using mean-variance optimization with covariance matrix regularization.
- **EW Allocation**: Assigns equal weights to all assets.
- **HRP Allocation**: Uses hierarchical clustering and recursive bisection for risk-based allocation.
- **Fully Unit-Tested**: Includes test cases for correctness verification.

## Installation

Add `cutup` to your `Cargo.toml`:

```toml
[dependencies]
cutup = "0.1.4"
```

## Usage

```rust
use nalgebra::DMatrix;
use cutup::PortfolioAllocator;

fn main() {
    let prices = DMatrix::from_row_slice(
        4,
        4,
        &[
            125.0, 1500.0, 210.0, 600.0,
            123.0, 1520.0, 215.0, 620.0,
            130.0, 1510.0, 220.0, 610.0,
            128.0, 1530.0, 225.0, 630.0,
        ],
    );

    let allocator = PortfolioAllocator::new(prices);

    let mvo_weights = allocator.mvo_allocation();
    let ew_weights = allocator.ew_allocation();
    let hrp_weights = allocator.hrp_allocation();

    println!("MVO Weights: {:?}", mvo_weights);
    println!("EW Weights: {:?}", ew_weights);
    println!("HRP Weights: {:?}", hrp_weights);

    // or do it all in one go

    let weights = run_portfolio_allocation(prices);
    println!("Portfolio Weights: {:?}", weights);
}
```

## License

This project is licensed under the MIT License.