sciencecalc-rs 0.1.0

A calculation toolkit or Library for mathematics, physics, and chemistry in Rust | Library rust Matematika, Fisika, Kimia - Kalkulator Toolkit
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

/// Modul Statistik - Statistics Module
/// Fitur: Mean, Median, Mode, Variance, Standard Deviation
/// Features: Mean, Median, Mode, Variance, Standard Deviation

use std::collections::HashMap;

pub struct Statistika;

impl Statistika {
    /// Menghitung rata-rata (mean)
    pub fn mean(data: &[f64]) -> f64 {
        if data.is_empty() {
            panic!("Tidak bisa menghitung rata-rata dari array kosong.");
        }
        let sum: f64 = data.iter().sum();
        sum / (data.len() as f64)
    }

    /// Menghitung median
    pub fn median(data: &mut [f64]) -> f64 {
        if data.is_empty() {
            panic!("Tidak dapat menghitung median dari data kosong.");
        }
        data.sort_by(|a, b| a.partial_cmp(b).unwrap());
        let len = data.len();
        if len % 2 == 0 {
            (data[len / 2 - 1] + data[len / 2]) / 2.0
        } else {
            data[len / 2]
        }
    }

    /// Menghitung modus (support data lebih dari satu modus)
    pub fn modus(data: &[i64]) -> Vec<i64> {
        if data.is_empty() {
            panic!("Tidak dapat menghitung modus dari data kosong.");
        }
        let mut frekuensi = HashMap::new();
        for &num in data {
            *frekuensi.entry(num).or_insert(0) += 1;
        }
        let max_freq = frekuensi.values().copied().max().unwrap();
        frekuensi
            .into_iter()
            .filter(|&(_, count)| count == max_freq)
            .map(|(num, _)| num)
            .collect()
    }

    /// Menghitung varian
    pub fn varian(data: &[f64]) -> f64 {
        if data.is_empty() {
            panic!("Tidak dapat menghitung varian dari data kosong.");
        }
        let mean = Self::mean(data);
        let sq_diff: f64 = data.iter().map(|value| (value - mean).powi(2)).sum();
        sq_diff / (data.len() as f64)
    }

    /// Menghitung standar deviasi
    pub fn standar_deviasi(data: &[f64]) -> f64 {
        Self::varian(data).sqrt()
    }
}