qcdiff-core 0.1.0

Semantic diff for OpenQASM 3 quantum circuits: parse, normalize, and diff operation streams (library behind the qcdiff CLI)
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129

//! Alignment and rendering of two operation streams.

use crate::stream::{Extracted, Op};
use similar::{capture_diff_slices, Algorithm, DiffOp};

#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Change {
    Same,
    Removed,
    Added,
    /// Same alignment key (op + operands) but different parameters/content.
    Modified,
}

#[derive(Debug)]
pub struct DiffLine {
    pub change: Change,
    /// Rendering of the old op (Removed/Same/Modified) or new op (Added).
    pub text: String,
    /// For Modified: rendering of the new parameters.
    pub new_params: Option<String>,
}

pub struct DiffResult {
    pub lines: Vec<DiffLine>,
    pub added: usize,
    pub removed: usize,
    pub modified: usize,
}

impl DiffResult {
    pub fn has_changes(&self) -> bool {
        self.added + self.removed + self.modified > 0
    }
}

/// Diff two streams. Alignment uses the parameter-free key so that a
/// parameter-only change pairs up and reports as `~` instead of `-`/`+`.
pub fn diff(a: &Extracted, b: &Extracted) -> DiffResult {
    let keys_a: Vec<String> = a.ops.iter().map(Op::align_key).collect();
    let keys_b: Vec<String> = b.ops.iter().map(Op::align_key).collect();
    let ops = capture_diff_slices(Algorithm::Patience, &keys_a, &keys_b);

    let mut lines = Vec::new();
    let (mut added, mut removed, mut modified) = (0usize, 0usize, 0usize);

    for op in ops {
        match op {
            DiffOp::Equal {
                old_index,
                new_index,
                len,
            } => {
                for k in 0..len {
                    let oa = &a.ops[old_index + k];
                    let ob = &b.ops[new_index + k];
                    if oa.params == ob.params {
                        lines.push(DiffLine {
                            change: Change::Same,
                            text: oa.render(),
                            new_params: None,
                        });
                    } else {
                        modified += 1;
                        lines.push(DiffLine {
                            change: Change::Modified,
                            text: oa.render(),
                            new_params: Some(ob.params.clone()),
                        });
                    }
                }
            }
            DiffOp::Delete {
                old_index, old_len, ..
            } => {
                for k in 0..old_len {
                    removed += 1;
                    lines.push(DiffLine {
                        change: Change::Removed,
                        text: a.ops[old_index + k].render(),
                        new_params: None,
                    });
                }
            }
            DiffOp::Insert {
                new_index, new_len, ..
            } => {
                for k in 0..new_len {
                    added += 1;
                    lines.push(DiffLine {
                        change: Change::Added,
                        text: b.ops[new_index + k].render(),
                        new_params: None,
                    });
                }
            }
            DiffOp::Replace {
                old_index,
                old_len,
                new_index,
                new_len,
            } => {
                for k in 0..old_len {
                    removed += 1;
                    lines.push(DiffLine {
                        change: Change::Removed,
                        text: a.ops[old_index + k].render(),
                        new_params: None,
                    });
                }
                for k in 0..new_len {
                    added += 1;
                    lines.push(DiffLine {
                        change: Change::Added,
                        text: b.ops[new_index + k].render(),
                        new_params: None,
                    });
                }
            }
        }
    }

    DiffResult {
        lines,
        added,
        removed,
        modified,
    }
}