laddu-kernel 0.21.4

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
94

use super::*;

impl KernelInstruction {
    /// Returns the stable instruction name used in diagnostics and support reporting.
    pub fn diagnostic_name(&self) -> &'static str {
        match self {
            Self::Cached(_) => "Cached",
            Self::RealConstant(_) => "RealConstant",
            Self::ComplexConstant(_) => "ComplexConstant",
            Self::Parameter(_) => "Parameter",
            Self::Unary { .. } => "Unary",
            Self::Binary { .. } => "Binary",
            Self::Add(_) => "Add",
            Self::Mul(_) => "Mul",
            Self::Complex { .. } => "Complex",
            Self::Vector(_) => "Vector",
            Self::Matrix { .. } => "Matrix",
            Self::Component { .. } => "Component",
            Self::MatrixElement { .. } => "MatrixElement",
            Self::MatMul { .. } => "MatMul",
            Self::MatVec { .. } => "MatVec",
            Self::Dot { .. } => "Dot",
            Self::Solve { .. } => "Solve",
            Self::SolveRow { .. } => "SolveRow",
            Self::SolveRowAdjointElement { .. } => "SolveRowAdjointElement",
        }
    }

    /// Returns the backend-independent event-dependence rule for this instruction.
    pub fn event_dependence(&self) -> KernelEventDependence {
        match self {
            Self::Cached(_) | Self::SolveRow { .. } | Self::SolveRowAdjointElement { .. } => {
                KernelEventDependence::Event
            }
            Self::RealConstant(_) | Self::ComplexConstant(_) | Self::Parameter(_) => {
                KernelEventDependence::Invariant
            }
            _ => KernelEventDependence::Operands,
        }
    }

    /// Returns the direct input value identifiers.
    pub fn operands(&self) -> Vec<KernelValueId> {
        let mut operands = Vec::new();
        self.visit_operands(|operand| operands.push(operand));
        operands
    }

    pub(super) fn visit_operands(&self, mut visit: impl FnMut(KernelValueId)) {
        match self {
            Self::Cached(_)
            | Self::RealConstant(_)
            | Self::ComplexConstant(_)
            | Self::Parameter(_) => {}
            Self::Unary { input, .. }
            | Self::Component { input, .. }
            | Self::MatrixElement { input, .. }
            | Self::SolveRowAdjointElement { adjoint: input, .. } => visit(*input),
            Self::Binary { lhs, rhs, .. } | Self::MatMul { lhs, rhs } | Self::Dot { lhs, rhs } => {
                visit(*lhs);
                visit(*rhs);
            }
            Self::MatVec { matrix, vector }
            | Self::Solve {
                matrix,
                rhs: vector,
            } => {
                visit(*matrix);
                visit(*vector);
            }
            Self::Add(values)
            | Self::Mul(values)
            | Self::Vector(values)
            | Self::SolveRow { rhs: values, .. } => values.iter().copied().for_each(visit),
            Self::Complex { re, im } => {
                visit(*re);
                visit(*im);
            }
            Self::Matrix { elements, .. } => elements.iter().copied().for_each(visit),
        }
    }

    pub(super) fn validate_operand_order(&self, value: usize) -> Result<(), KernelIrError> {
        let mut invalid_operand = None;
        self.visit_operands(|operand| {
            if invalid_operand.is_none() && operand.index() >= value {
                invalid_operand = Some(operand.index());
            }
        });
        invalid_operand.map_or(Ok(()), |operand| {
            Err(KernelIrError::InvalidOperand { value, operand })
        })
    }
}