laddu-compile 0.21.2

Amplitude analysis tools for Rust
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

use laddu_expr::{
    BinaryOp, Expr, ExprId, ExprMetadata, UnaryOp, complex, dot, event_scalar, matmul, matrix,
    matvec, parameter, parameters::Parameter, polar_complex, vector,
};
use num::complex::Complex64;

use super::*;

#[derive(Copy, Clone, Debug)]
struct WrapRootInExp;

impl OptimizationPass for WrapRootInExp {
    fn name(&self) -> &'static str {
        "wrap-root-in-exp"
    }

    fn run(&self, graph: ExprGraph) -> CompileResult<ExprGraph> {
        let mut nodes = graph.nodes().to_vec();
        let mut metadata = graph
            .nodes()
            .iter()
            .enumerate()
            .map(|(index, _)| {
                graph
                    .metadata(ExprId::from_index(index))
                    .expect("graph metadata length is validated")
                    .clone()
            })
            .collect::<Vec<_>>();
        let root = ExprId::from_index(nodes.len());
        nodes.push(ExprNode::Unary {
            op: UnaryOp::Exp,
            input: graph.root(),
        });
        metadata.push(ExprMetadata::new(laddu_expr::ExprSourceKind::Unary));
        Ok(ExprGraph::from_parts(root, nodes, metadata)?)
    }
}

fn count_binary_op(compiled: &CompiledModel, op: BinaryOp) -> usize {
    compiled
        .graph()
        .nodes()
        .iter()
        .filter(|node| matches!(node, ExprNode::Binary { op: node_op, .. } if *node_op == op))
        .count()
}

fn count_nary_add(compiled: &CompiledModel) -> usize {
    compiled
        .graph()
        .nodes()
        .iter()
        .filter(|node| matches!(node, ExprNode::NaryAdd { .. }))
        .count()
}

fn count_nary_mul(compiled: &CompiledModel) -> usize {
    compiled
        .graph()
        .nodes()
        .iter()
        .filter(|node| matches!(node, ExprNode::NaryMul { .. }))
        .count()
}

fn count_unary_op(compiled: &CompiledModel, op: UnaryOp) -> usize {
    compiled
        .graph()
        .nodes()
        .iter()
        .filter(|node| matches!(node, ExprNode::Unary { op: node_op, .. } if *node_op == op))
        .count()
}

fn has_real_const(compiled: &CompiledModel, expected: f64) -> bool {
    compiled.graph().nodes().iter().any(|node| {
            matches!(node, ExprNode::RealConst(value) if (*value - expected).abs() <= f64::EPSILON * expected.abs().max(1.0) * 16.0)
        })
}

#[path = "tests/algebra.rs"]
mod algebra;
#[path = "tests/cse.rs"]
mod cse;
#[path = "tests/matrix.rs"]
mod matrix;
#[path = "tests/pipeline.rs"]
mod pipeline;
#[path = "tests/private.rs"]
mod private;
#[path = "tests/trig.rs"]
mod trig;