scyros 0.3.1

A framework to design sound, reproducible and scalable mining repositories studies on GitHub.
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

use std::f64::consts::PI;

// --- Trait: FloatOps (equivalent to Scala trait) ---

trait FloatOps {
    fn compute(&self, x: f64) -> f64;

    fn description(&self) -> &str {
        "Performs float operations"
    }
}

// --- Trait: AbstractFloatProcessor (equivalent to Scala abstract class) ---

trait AbstractFloatProcessor {
    fn process(&self, values: &[f64]) -> f64;
    fn name(&self) -> &str;
}

// --- Struct: ConcreteFloatProcessor ---

struct ConcreteFloatProcessor;

impl AbstractFloatProcessor for ConcreteFloatProcessor {
    fn process(&self, values: &[f64]) -> f64 {
        let mut sum = 0.0_f64;
        // Handle NaN values by treating them as zero
        for &v in values {
            sum += if v.is_nan() { 0.0 } else { v };
        }
        sum / if values.is_empty() { 1.0 } else { values.len() as f64 }
    }

    fn name(&self) -> &str {
        "ConcreteFloatProcessor"
    }
}

impl FloatOps for ConcreteFloatProcessor {
    fn compute(&self, x: f64) -> f64 {
        if x == f64::INFINITY {
            0.0
        } else if x == f64::NEG_INFINITY {
            0.0
        } else if x.is_nan() {
            -1.0
        } else if x > 0.0 {
            x.sqrt() + x.ln()
        } else if x < 0.0 {
            x.abs() * x.sin()
        } else {
            0.0
        }
    }
}

// --- Module: FloatUtils (equivalent to Scala companion object) ---

mod float_utils {
    pub fn factorial(n: u32) -> f64 {
        let mut result = 1.0_f64;
        let mut i = 1_u32;
        while i <= n {
            result *= i as f64;
            i += 1;
        }
        result
    }

    pub fn sum_until_epsilon(start: f64, epsilon: f64) -> f64 {
        let mut sum = 0.0_f64;
        let mut term = start;
        // This loop continues to add terms until the absolute value of the term
        // is less than epsilon. The term is halved each iteration,
        // simulating a converging series.
        loop {
            sum += term;
            term /= 2.0;
            if term.abs() <= epsilon {
                break;
            }
        }
        sum
    }

    pub fn find_first_negative(xs: &[f64]) -> Option<f64> {
        xs.iter().copied().find(|&x| x < 0.0)
    }

    pub fn transcendental_ops(x: f64) -> f64 {
        x.exp() + x.cos() - x.tanh()
    }

    pub fn special_values_demo() -> Vec<f64> {
        vec![
            f64::NAN,
            f64::INFINITY,
            f64::NEG_INFINITY,
            f64::MIN,
            f64::MAX,
            0.0,
            -0.0,
        ]
    }
}

// --- Main ---

fn main() {
    let processor = ConcreteFloatProcessor;
    let data: Vec<f64> = vec![1.0, 2.0, f64::NAN, -3.0, f64::INFINITY];

    println!("Processed: {}", processor.process(&data));
    println!("Compute(4.0): {}", processor.compute(4.0));
    println!("Factorial(5): {}", float_utils::factorial(5));
    println!(
        "Sum until epsilon: {}",
        float_utils::sum_until_epsilon(1.0, 1e-5)
    );
    println!(
        "First negative: {:?}",
        float_utils::find_first_negative(&data)
    );
    println!(
        "Transcendental ops: {}",
        float_utils::transcendental_ops(PI)
    );

    let special: Vec<String> = float_utils::special_values_demo()
        .iter()
        .map(|v| v.to_string())
        .collect();
    println!("Special values: {}", special.join(", "));
}