unlab-gpu 0.1.0

Micro scripting language for neural networks that uses unmtx-gpu.
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

//
// Copyright (c) 2025-2026 Łukasz Szpakowski
//
// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at https://mozilla.org/MPL/2.0/.
//
//! A module of DFS algorithm.
use std::collections::HashSet;
use std::hash::Hash;

/// An enumeration of DFS result.
#[derive(Clone, Debug)]
pub enum DfsResult<T>
{
    /// A success
    Success,
    /// A cycle.
    Cycle(Vec<T>),
}

fn find_cycle<T: Clone + Eq + Hash>(u: &T, vs: &[T], stack: &[(T, Vec<T>)], processeds: &HashSet<T>) -> DfsResult<T>
{
    match vs.iter().find(|v| processeds.contains(v)) {
        Some(v) => {
            let mut cycle: Vec<T> = stack.iter().map(|p| p.0.clone()).collect();
            cycle.push(u.clone());
            cycle.push(v.clone());
            DfsResult::Cycle(cycle)
        },
        None => DfsResult::Success,
    }
}

/// This function is an implementation of DFS algorithm with a cycle detection.
///
/// A graph is depth-first searched by this function. This function returns a path with the cycle
/// if this function detects a cycle in the graph, otherwise returns a success.
pub fn dfs<T: Clone + Eq + Hash, U, F, G, E>(start: &T, visiteds: &mut HashSet<T>, data: &mut U, mut f: F, mut g: G) -> Result<DfsResult<T>, E>
    where F: FnMut(&T, &mut U) -> Result<Vec<T>, E>,
          G: FnMut(&T, &mut U) -> Result<(), E>
{
    let mut stack: Vec<(T, Vec<T>)> = Vec::new();
    let mut processeds: HashSet<T> = HashSet::new();
    processeds.insert(start.clone());
    let mut us = f(start, data)?;
    match find_cycle(start, us.as_slice(), stack.as_slice(), &processeds) {
        DfsResult::Success => (),
        res @ DfsResult::Cycle(_) => return Ok(res),
    }
    us.reverse();
    stack.push((start.clone(), us));
    visiteds.insert(start.clone());
    loop {
        match stack.last_mut() {
            Some((u, vs)) => {
                let v = loop {
                    match vs.pop() {
                        Some(w) if !visiteds.contains(&w) => break Some(w),
                        Some(_) => (),
                        None => break None,
                    }
                };
                match v {
                    Some(v) => {
                        processeds.insert(v.clone());
                        let mut ws = f(&v, data)?;
                        match find_cycle(&v, ws.as_slice(), stack.as_slice(), &processeds) {
                            DfsResult::Success => (),
                            res @ DfsResult::Cycle(_) => return Ok(res),
                        }
                        ws.reverse();
                        stack.push((v.clone(), ws));
                        visiteds.insert(v);
                    },
                    None => {
                        g(u, data)?;
                        processeds.remove(u);
                        stack.pop();
                    },
                }
            },
            None => break,
        }
    }
    Ok(DfsResult::Success)
}

#[cfg(test)]
mod tests;