avila-math 0.1.0

Arxis Foundation: The ARX (fortress) - Mathematical kernel with quaternions, tensors, 4D geometry, Conv4D, differential operators
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
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107

//! Operations for automatic differentiation

use super::tape::{Operation, Tape};
use super::variable::Variable;

/// Add two variables
pub fn add(tape: &mut Tape, a: &Variable, b: &Variable) -> Variable {
    let value = a.value() + b.value();
    tape.record(
        value,
        Operation::Add {
            a: a.clone(),
            b: b.clone(),
        },
    )
}

/// Subtract two variables
pub fn sub(tape: &mut Tape, a: &Variable, b: &Variable) -> Variable {
    let value = a.value() - b.value();
    tape.record(
        value,
        Operation::Sub {
            a: a.clone(),
            b: b.clone(),
        },
    )
}

/// Multiply two variables
pub fn mul(tape: &mut Tape, a: &Variable, b: &Variable) -> Variable {
    let value = a.value() * b.value();
    tape.record(
        value,
        Operation::Mul {
            a: a.clone(),
            b: b.clone(),
        },
    )
}

/// Divide two variables
pub fn div(tape: &mut Tape, a: &Variable, b: &Variable) -> Variable {
    let value = a.value() / b.value();
    tape.record(
        value,
        Operation::Div {
            a: a.clone(),
            b: b.clone(),
        },
    )
}

/// Power (a^b where b is constant)
pub fn pow(tape: &mut Tape, a: &Variable, exponent: f64) -> Variable {
    let value = a.value().powf(exponent);
    tape.record(
        value,
        Operation::Pow {
            a: a.clone(),
            b: exponent,
        },
    )
}

/// Exponential
pub fn exp(tape: &mut Tape, a: &Variable) -> Variable {
    let value = a.value().exp();
    tape.record(value, Operation::Exp { a: a.clone() })
}

/// Natural logarithm
pub fn log(tape: &mut Tape, a: &Variable) -> Variable {
    let value = a.value().ln();
    tape.record(value, Operation::Log { a: a.clone() })
}

/// Sine
pub fn sin(tape: &mut Tape, a: &Variable) -> Variable {
    let value = a.value().sin();
    tape.record(value, Operation::Sin { a: a.clone() })
}

/// Cosine
pub fn cos(tape: &mut Tape, a: &Variable) -> Variable {
    let value = a.value().cos();
    tape.record(value, Operation::Cos { a: a.clone() })
}

/// Hyperbolic tangent
pub fn tanh(tape: &mut Tape, a: &Variable) -> Variable {
    let value = a.value().tanh();
    tape.record(value, Operation::Tanh { a: a.clone() })
}

/// ReLU activation
pub fn relu(tape: &mut Tape, a: &Variable) -> Variable {
    let value = a.value().max(0.0);
    tape.record(value, Operation::Relu { a: a.clone() })
}

/// Sigmoid activation
pub fn sigmoid(tape: &mut Tape, a: &Variable) -> Variable {
    let a_val = a.value();
    let value = 1.0 / (1.0 + (-a_val).exp());
    tape.record(value, Operation::Sigmoid { a: a.clone() })
}