deep_causality_tensor 0.2.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
60
61

/*
 * SPDX-License-Identifier: MIT
 * Copyright (c) "2025" . 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 CausalTensor::new(vec![], self.shape().to_vec()); // Correctly return an empty tensor
        }
        let new_data = self.as_slice().iter().map(|&val| val.ln()).collect();
        CausalTensor::new(new_data, self.shape().to_vec())
    }

    fn log2(&self) -> Result<CausalTensor<f64>, CausalTensorError> {
        if self.is_empty() {
            return CausalTensor::new(vec![], self.shape().to_vec()); // Correctly return an empty tensor
        }

        let new_data = self.as_slice().iter().map(|&val| val.log2()).collect();
        CausalTensor::new(new_data, self.shape().to_vec())
    }

    fn log10(&self) -> Result<CausalTensor<f64>, CausalTensorError> {
        if self.is_empty() {
            return CausalTensor::new(vec![], self.shape().to_vec()); // Correctly return an empty tensor
        }

        let new_data = self.as_slice().iter().map(|&val| val.log10()).collect();
        CausalTensor::new(new_data, self.shape().to_vec())
    }

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

    fn safe_div(&self, rhs: &CausalTensor<f64>) -> Result<CausalTensor<f64>, CausalTensorError> {
        self.broadcast_op(rhs, |numerator, denominator| {
            if denominator.abs() < 1e-14 {
                // If denominator is zero, the result is only well-defined if numerator is also zero.
                if numerator.abs() < 1e-14 {
                    Ok(0.0) // The 0/0 case, which means zero information.
                } else {
                    // This is a true error state (e.g. 1/0)
                    Err(CausalTensorError::DivisionByZero)
                }
            } else {
                Ok(numerator / denominator)
            }
        })
    }
}