Linspace bug follow up with no bugs

qupulse/program/linspace.py

@@ -499,7 +499,7 @@ def __init__(self, channels: int,
         self.time = TimeType(0)
         self.registers = tuple({} for _ in range(channels))
 
-        self.history: List[Tuple[TimeType, Tuple[float, ...]]] = []
+        self.history: List[Tuple[TimeType, List[float]]] = []
 
         self.commands = None
         self.label_targets = None
@@ -523,9 +523,13 @@ def change_state(self, cmd: Union[Set, Increment, Wait, Play]):
                 self.time += dt
                 t += dt
         elif isinstance(cmd, Wait):
-            self.history.append(
-                (self.time, self.current_values.copy())
-            )
+            if self.history and self.history[-1][1] == self.current_values:
+                # do not create noop entries
+                pass
+            else:
+                self.history.append(
+                    (self.time, self.current_values.copy())
+                )
             self.time += cmd.duration
         elif isinstance(cmd, Set):
             self.current_values[cmd.channel] = cmd.value

tests/program/linspace_tests.py

@@ -65,25 +65,25 @@ def test_output(self):
 
 class SequencedRepetitionTest(TestCase):
     def setUp(self):
-        
+
         base_time = 1e2
         rep_factor = 2
-          
+
         wait = AtomicMultiChannelPT(
             ConstantPT(f'{base_time}', {'a': '-1. + idx_a * 0.01', }),
             ConstantPT(f'{base_time}', {'b': '-0.5 + idx_b * 0.05'})
             )
-        
+
         dependent_constant = AtomicMultiChannelPT(
             ConstantPT(base_time, {'a': '-1.0 '}),
-            ConstantPT(base_time, {'b': '-0.5 + idx_b*0.05',}),            
+            ConstantPT(base_time, {'b': '-0.5 + idx_b*0.05',}),
             )
-        
+
         dependent_constant2 = AtomicMultiChannelPT(
             ConstantPT(base_time, {'a': '-0.5 '}),
-            ConstantPT(base_time, {'b': '-0.3 + idx_b*0.05',}),            
+            ConstantPT(base_time, {'b': '-0.3 + idx_b*0.05',}),
             )
-        
+
         #not working
         self.pulse_template = (
                 dependent_constant @
@@ -174,8 +174,9 @@ def setUp(self):
             self.output.append((time, (-1.0, -0.5 + idx_b * 0.05)))
             time += TimeType.from_float(base_time)
 
+            # The VM does not create noop entries
+            self.output.append((time, (-0.5, -0.3 + idx_b * 0.05)))
             for _ in range(rep_factor):
-                self.output.append((time, (-0.5, -0.3 + idx_b * 0.05)))
                 time += TimeType.from_float(base_time)
 
             for idx_a in range(rep_factor):
@@ -198,6 +199,68 @@ def test_output_1(self):
         assert_vm_output_almost_equal(self, self.output, vm.history)
 
 
+class PrePostDepTest(TestCase):
+    def setUp(self):
+        hold = ConstantPT(10 ** 6, {'a': '-1. + idx * 0.01'})
+        hold_random = ConstantPT(10 ** 5, {'a': -.4})
+        # self.pulse_template = (hold_random@(hold_random@hold).with_repetition(10)@hold_random@hold)\
+        self.pulse_template = (hold_random @ hold.with_repetition(10)).with_iteration('idx', 200)
+
+        self.program = LinSpaceIter(
+            length=200,
+            body=(
+                LinSpaceHold(bases=(-.4,), factors=(None,), duration_base=TimeType(10**5), duration_factors=None),
+                LinSpaceRepeat(body=(
+                LinSpaceHold(bases=(-1.,),factors=((0.01,),),duration_base=TimeType(10**6),duration_factors=None),
+                ), count=10),
+                # LinSpaceHold(bases=(-.4),factors=None,duration_base=TimeType(10**6),duration_factors=None),
+                # LinSpaceHold(bases=(-1.,),factors=((0.01,),),duration_base=TimeType(10**6),duration_factors=None)
+            ),)
+
+        self.commands = [
+            Set(channel=0, value=-0.4, key=DepKey(factors=())),
+             Wait(duration=TimeType(100000, 1)),
+             Set(channel=0, value=-1.0, key=DepKey(factors=(10000000,))),
+             Wait(duration=TimeType(1000000, 1)),
+             LoopLabel(idx=0, count=9),
+             Wait(duration=TimeType(1000000, 1)),
+             LoopJmp(idx=0),
+             LoopLabel(idx=1, count=199),
+             Set(channel=0, value=-0.4, key=DepKey(factors=())),
+             Wait(duration=TimeType(100000, 1)),
+             Increment(channel=0, value=0.01, dependency_key=DepKey(factors=(10000000,))),
+             Wait(duration=TimeType(1000000, 1)),
+             LoopLabel(idx=2, count=9),
+             Wait(duration=TimeType(1000000, 1)),
+             LoopJmp(idx=2),
+             LoopJmp(idx=1)
+        ]
+
+        self.output = []
+        time = TimeType(0)
+        for idx in range(200):
+            self.output.append((time, [-.4]))
+            time += TimeType(10**5)
+            self.output.append((time, [-1. + idx * 0.01]))
+            time += TimeType(10**7)
+
+
+    def test_program(self):
+        program_builder = LinSpaceBuilder(('a',))
+        program = self.pulse_template.create_program(program_builder=program_builder)
+        self.assertEqual([self.program], program)
+
+    def test_commands(self):
+        commands = to_increment_commands([self.program])
+        self.assertEqual(self.commands, commands)
+
+    def test_output(self):
+        vm = LinSpaceVM(1)
+        vm.set_commands(self.commands)
+        vm.run()
+        assert_vm_output_almost_equal(self, self.output, vm.history)
+
+
 class PlainCSDTest(TestCase):
     def setUp(self):
         hold = ConstantPT(10**6, {'a': '-1. + idx_a * 0.01', 'b': '-.5 + idx_b * 0.02'})