deep_causality_tensor 0.4.0

Tensor data structure for for deep_causality crate.
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

/*
 * SPDX-License-Identifier: MIT
 * Copyright (c) 2023 - 2026. The DeepCausality Authors and Contributors. All Rights Reserved.
 */
use crate::{CausalTensor, CausalTensorError, CausalTensorMathExt};

impl CausalTensorMathExt<f64> for CausalTensor<f64> {
    fn log_nat(&self) -> Result<CausalTensor<f64>, CausalTensorError> {
        if self.is_empty() {
            return Ok(CausalTensor::from_slice(&[], self.shape()));
        }
        let new_data: Vec<f64> = self.as_slice().iter().map(|&val| val.ln()).collect();
        Ok(CausalTensor::from_slice(&new_data, self.shape()))
    }

    fn log2(&self) -> Result<CausalTensor<f64>, CausalTensorError> {
        if self.is_empty() {
            return Ok(CausalTensor::from_slice(&[], self.shape()));
        }

        let new_data: Vec<f64> = self.as_slice().iter().map(|&val| val.log2()).collect();
        Ok(CausalTensor::from_slice(&new_data, self.shape()))
    }

    fn log10(&self) -> Result<CausalTensor<f64>, CausalTensorError> {
        if self.is_empty() {
            return Ok(CausalTensor::from_slice(&[], self.shape()));
        }

        let new_data: Vec<f64> = self.as_slice().iter().map(|&val| val.log10()).collect();
        Ok(CausalTensor::from_slice(&new_data, self.shape()))
    }

    fn surd_log2(&self) -> Result<CausalTensor<f64>, CausalTensorError> {
        if self.is_empty() {
            return Ok(CausalTensor::from_slice(&[], self.shape()));
        }
        let new_data: Vec<f64> = self
            .as_slice()
            .iter()
            .map(|&val| if val == 0.0 { 0.0 } else { val.log2() })
            .collect();
        Ok(CausalTensor::from_slice(&new_data, self.shape()))
    }

    fn safe_div(&self, rhs: &CausalTensor<f64>) -> Result<CausalTensor<f64>, CausalTensorError> {
        self.broadcast_op(rhs, |numerator, denominator| {
            if denominator.abs() < 1e-14 {
                if numerator.abs() < 1e-14 {
                    Ok(0.0)
                } else {
                    Err(CausalTensorError::DivisionByZero)
                }
            } else {
                Ok(numerator / denominator)
            }
        })
    }
}