quantrs2-symengine-pure 0.1.3

Pure Rust symbolic mathematics for quantum computing - a replacement for C++-based symengine
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
108
109
110
111
112
113
114
115

//! Transcendental functions for symbolic expressions.

use crate::error::SymEngineResult;
use crate::expr::{ExprLang, Expression};
use egg::RecExpr;

/// Sine function
pub fn sin(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Sin)
}

/// Cosine function
pub fn cos(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Cos)
}

/// Tangent function
pub fn tan(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Tan)
}

/// Exponential function (e^x)
pub fn exp(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Exp)
}

/// Natural logarithm
pub fn log(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Log)
}

/// Logarithm with arbitrary base
pub fn log_base(x: &Expression, base: &Expression) -> Expression {
    log(x) / log(base)
}

/// Square root
pub fn sqrt(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Sqrt)
}

/// Absolute value
pub fn abs(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Abs)
}

/// Inverse sine (arcsin)
pub fn asin(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Asin)
}

/// Inverse cosine (arccos)
pub fn acos(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Acos)
}

/// Inverse tangent (arctan)
pub fn atan(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Atan)
}

/// Hyperbolic sine
pub fn sinh(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Sinh)
}

/// Hyperbolic cosine
pub fn cosh(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Cosh)
}

/// Hyperbolic tangent
pub fn tanh(x: &Expression) -> Expression {
    apply_unary(x, ExprLang::Tanh)
}

/// Helper function to apply a unary operation
fn apply_unary<F>(x: &Expression, make_node: F) -> Expression
where
    F: FnOnce([egg::Id; 1]) -> ExprLang,
{
    let mut expr = x.as_rec_expr().clone();
    let id = egg::Id::from(expr.as_ref().len() - 1);
    expr.add(make_node([id]));
    Expression::from_rec_expr(expr)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_trig_functions() {
        let x = Expression::symbol("x");

        let sin_x = sin(&x);
        let cos_x = cos(&x);
        let tan_x = tan(&x);

        assert!(!sin_x.is_symbol());
        assert!(!cos_x.is_symbol());
        assert!(!tan_x.is_symbol());
    }

    #[test]
    fn test_exp_log() {
        let x = Expression::symbol("x");

        let exp_x = exp(&x);
        let log_x = log(&x);

        assert!(!exp_x.is_symbol());
        assert!(!log_x.is_symbol());
    }
}