rhmm 0.0.2

A rust implementation of hidden markov models.
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
133
134
135
136
137
138
139
140
141
142
143
144
145
146

//! Sequence handling utilities for multiple sequences

use crate::errors::{HmmError, Result};
use ndarray::{Array2, ArrayView2};

/// Validate lengths parameter
///
/// # Arguments
///
/// * `observations` - Observation array
/// * `lengths` - Sequence lengths
///
/// # Returns
///
/// Result indicating if lengths are valid
pub fn validate_lengths(observations: &Array2<f64>, lengths: &[usize]) -> Result<()> {
    if lengths.is_empty() {
        return Err(HmmError::InvalidParameter(
            "Lengths array cannot be empty".to_string(),
        ));
    }

    let total_length: usize = lengths.iter().sum();
    if total_length != observations.nrows() {
        return Err(HmmError::InvalidParameter(format!(
            "Sum of lengths ({}) does not match number of observations ({})",
            total_length,
            observations.nrows()
        )));
    }

    for &length in lengths {
        if length == 0 {
            return Err(HmmError::InvalidParameter(
                "Sequence length cannot be zero".to_string(),
            ));
        }
    }

    Ok(())
}

/// Split observations into multiple sequences based on lengths
///
/// # Arguments
///
/// * `observations` - Concatenated observation sequences
/// * `lengths` - Length of each sequence
///
/// # Returns
///
/// Vector of observation sequences
pub fn split_sequences<'a>(
    observations: &'a Array2<f64>,
    lengths: &[usize],
) -> Result<Vec<ArrayView2<'a, f64>>> {
    validate_lengths(observations, lengths)?;

    let mut sequences = Vec::with_capacity(lengths.len());
    let mut start = 0;

    for &length in lengths {
        let end = start + length;
        let sequence = observations.slice(ndarray::s![start..end, ..]);
        sequences.push(sequence);
        start = end;
    }

    Ok(sequences)
}

/// Get default lengths (single sequence)
///
/// # Arguments
///
/// * `n_samples` - Total number of samples
///
/// # Returns
///
/// Vector with single length
pub fn default_lengths(n_samples: usize) -> Vec<usize> {
    vec![n_samples]
}

#[cfg(test)]
mod tests {
    use super::*;
    use ndarray::array;

    #[test]
    fn test_validate_lengths_valid() {
        let obs = array![[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0]];
        let lengths = vec![2, 2];
        assert!(validate_lengths(&obs, &lengths).is_ok());
    }

    #[test]
    fn test_validate_lengths_empty() {
        let obs = array![[1.0, 2.0]];
        let lengths: Vec<usize> = vec![];
        assert!(validate_lengths(&obs, &lengths).is_err());
    }

    #[test]
    fn test_validate_lengths_sum_mismatch() {
        let obs = array![[1.0, 2.0], [3.0, 4.0], [5.0, 6.0]];
        let lengths = vec![2, 2]; // Sum is 4, but obs has 3 rows
        assert!(validate_lengths(&obs, &lengths).is_err());
    }

    #[test]
    fn test_validate_lengths_zero_length() {
        let obs = array![[1.0, 2.0], [3.0, 4.0]];
        let lengths = vec![0, 2];
        assert!(validate_lengths(&obs, &lengths).is_err());
    }

    #[test]
    fn test_split_sequences_valid() {
        let obs = array![[1.0, 2.0], [3.0, 4.0], [5.0, 6.0], [7.0, 8.0], [9.0, 10.0]];
        let lengths = vec![2, 3];
        let sequences = split_sequences(&obs, &lengths).unwrap();

        assert_eq!(sequences.len(), 2);
        assert_eq!(sequences[0].nrows(), 2);
        assert_eq!(sequences[1].nrows(), 3);
        assert_eq!(sequences[0][[0, 0]], 1.0);
        assert_eq!(sequences[1][[0, 0]], 5.0);
    }

    #[test]
    fn test_split_sequences_single() {
        let obs = array![[1.0, 2.0], [3.0, 4.0]];
        let lengths = vec![2];
        let sequences = split_sequences(&obs, &lengths).unwrap();

        assert_eq!(sequences.len(), 1);
        assert_eq!(sequences[0].nrows(), 2);
    }

    #[test]
    fn test_default_lengths() {
        let lengths = default_lengths(10);
        assert_eq!(lengths, vec![10]);
    }
}