oris-runtime 0.15.0

An agentic workflow runtime and programmable AI execution system in Rust: stateful graphs, agents, tools, and multi-step execution.
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

//! 向量操作工具函数
//!
//! 提供向量平均、求和等常用操作。

/// 计算多个向量的平均值
///
/// # 参数
/// - `embeddings`: 向量列表
///
/// # 返回
/// 平均向量
///
/// # 示例
/// ```rust
/// use oris_runtime::utils::mean_embedding_f64;
///
/// let embeddings = vec![
///     vec![1.0, 2.0],
///     vec![3.0, 4.0],
/// ];
/// let mean = mean_embedding_f64(&embeddings);
/// assert_eq!(mean, vec![2.0, 3.0]);
/// ```
pub fn mean_embedding_f64(embeddings: &[Vec<f64>]) -> Vec<f64> {
    if embeddings.is_empty() {
        return Vec::new();
    }

    embeddings
        .iter()
        .fold(
            vec![0f64; embeddings[0].len()],
            |mut accumulator, embedding_vec| {
                for (i, &value) in embedding_vec.iter().enumerate() {
                    accumulator[i] += value;
                }
                accumulator
            },
        )
        .iter()
        .map(|&sum| sum / embeddings.len() as f64)
        .collect()
}

/// 计算多个向量的和
///
/// # 参数
/// - `vectors`: 向量列表
///
/// # 返回
/// 向量和
///
/// # 示例
/// ```rust
/// use oris_runtime::utils::sum_vectors_f64;
///
/// let vectors = vec![
///     vec![1.0, 2.0],
///     vec![3.0, 4.0],
/// ];
/// let sum = sum_vectors_f64(&vectors);
/// assert_eq!(sum, vec![4.0, 6.0]);
/// ```
pub fn sum_vectors_f64(vectors: &[Vec<f64>]) -> Vec<f64> {
    if vectors.is_empty() {
        return Vec::new();
    }

    let mut sum_vec = vec![0.0; vectors[0].len()];
    for vec in vectors {
        for (i, &value) in vec.iter().enumerate() {
            sum_vec[i] += value;
        }
    }
    sum_vec
}

/// 计算多个向量的平均值 (f32 精度)
pub fn mean_embedding_f32(embeddings: &[Vec<f32>]) -> Vec<f32> {
    if embeddings.is_empty() {
        return Vec::new();
    }

    embeddings
        .iter()
        .fold(
            vec![0f32; embeddings[0].len()],
            |mut accumulator, embedding_vec| {
                for (i, &value) in embedding_vec.iter().enumerate() {
                    accumulator[i] += value;
                }
                accumulator
            },
        )
        .iter()
        .map(|&sum| sum / embeddings.len() as f32)
        .collect()
}

/// 计算多个向量的和 (f32 精度)
pub fn sum_vectors_f32(vectors: &[Vec<f32>]) -> Vec<f32> {
    if vectors.is_empty() {
        return Vec::new();
    }

    let mut sum_vec = vec![0.0f32; vectors[0].len()];
    for vec in vectors {
        for (i, &value) in vec.iter().enumerate() {
            sum_vec[i] += value;
        }
    }
    sum_vec
}

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

    #[test]
    fn test_mean_embedding_f64() {
        let embeddings = vec![vec![1.0, 2.0], vec![3.0, 4.0]];
        let mean = mean_embedding_f64(&embeddings);
        assert_eq!(mean, vec![2.0, 3.0]);
    }

    #[test]
    fn test_mean_embedding_f64_empty() {
        let embeddings: Vec<Vec<f64>> = vec![];
        let mean = mean_embedding_f64(&embeddings);
        assert!(mean.is_empty());
    }

    #[test]
    fn test_sum_vectors_f64() {
        let vectors = vec![vec![1.0, 2.0], vec![3.0, 4.0]];
        let sum = sum_vectors_f64(&vectors);
        assert_eq!(sum, vec![4.0, 6.0]);
    }

    #[test]
    fn test_sum_vectors_f64_empty() {
        let vectors: Vec<Vec<f64>> = vec![];
        let sum = sum_vectors_f64(&vectors);
        assert!(sum.is_empty());
    }
}