def test_get_entries_instantiated_two_equal_entries(self) -> None: table = TablePulseTemplate({0: [(0, 0), (1, 5), (3, 5), (5, 1)]}) entries = table.get_entries_instantiated(dict()) expected = [ TableEntry(0, 0, HoldInterpolationStrategy()), TableEntry(1, 5, HoldInterpolationStrategy()), TableEntry(3, 5, HoldInterpolationStrategy()), TableEntry(5, 1, HoldInterpolationStrategy()) ] self.assertEqual({0: expected}, entries)
def test_get_instantiated_entries_multi_same_time_param(self) -> None: table = TablePulseTemplate({ 0: [(1, 3), ('foo', 'bar'), (7, 3)], 1: [(0, -5), (0.5, -2), ('foo', 0), (5, 'bar')] }) parameters = {'foo': 2.7, 'bar': -3.3} entries = table.get_entries_instantiated(parameters) expected = { 0: [ TableEntry(0, 3, HoldInterpolationStrategy()), TableEntry(1, 3, HoldInterpolationStrategy()), TableEntry(2.7, -3.3, HoldInterpolationStrategy()), TableEntry(7, 3, HoldInterpolationStrategy()), ], 1: [ TableEntry(0, -5, HoldInterpolationStrategy()), TableEntry(0.5, -2, HoldInterpolationStrategy()), TableEntry(2.7, 0, HoldInterpolationStrategy()), TableEntry(5, -3.3, HoldInterpolationStrategy()), TableEntry(7, -3.3, HoldInterpolationStrategy()) ] } self.assertEqual(expected, entries)
def integral(self) -> Dict[ChannelID, ExpressionScalar]: expressions = {} shape = (len(self.defined_channels),) for i, channel in enumerate(self._channels): def value_trafo(v): try: return v.underlying_expression[i] except TypeError: return IndexedBroadcast(v.underlying_expression, shape, i) pre_entry = TableEntry(0, self._entries[0].v, None) entries = [pre_entry] + self._entries expressions[channel] = TableEntry._sequence_integral(entries, expression_extractor=value_trafo) return expressions
def test_single_channel_no_parameters(self): raw_entries = [(0., 1.1), (1.1, 2.), (2.2, 2.4)] table = TablePulseTemplate({0: raw_entries}) expected = [TableEntry(*entry) for entry in raw_entries] self.assertEqual(table.entries, dict([(0, expected)])) self.assertEqual(table.duration, 2.2) self.assertEqual(table.parameter_names, set())
def test_from_array_1D(self) -> None: times = numpy.array([0, 1, 3]) voltages = numpy.array([5, 0, 5]) pulse = TablePulseTemplate.from_array(times, voltages, [0]) entries = [] for (time, voltage) in zip(times, voltages): entries.append(TableEntry(time, voltage, HoldInterpolationStrategy())) self.assertEqual({0: entries}, pulse.entries)
def test_from_array_multi_one_voltage(self) -> None: times = numpy.array([[0, 1, 3], [2, 3, 4]]) voltages = numpy.array([1, 2, 3]) pulse = TablePulseTemplate.from_array(times, voltages, [0, 1]) entries = { i: [TableEntry(time, voltage, HoldInterpolationStrategy()) for (time, voltage) in zip(times[i, :], voltages)] for i in range(2)} self.assertEqual(entries, pulse.entries)
def test_known_interpolation_strategies(self): strategies = [("linear", LinearInterpolationStrategy()), ("hold", HoldInterpolationStrategy()), ("jump", JumpInterpolationStrategy())] for strat_name, strat_val in strategies: entry = TableEntry('a', Expression('b'), strat_name) self.assertEqual(entry.t, Expression('a')) self.assertEqual(entry.v, Expression('b')) self.assertEqual(entry.interp, strat_val)
def _as_expression(self) -> Dict[ChannelID, ExpressionScalar]: t = self._AS_EXPRESSION_TIME shape = (len(self.defined_channels),) expressions = {} for i, channel in enumerate(self._channels): def value_trafo(v): try: return v.underlying_expression[i] except TypeError: return IndexedBroadcast(v.underlying_expression, shape, i) pre_value = value_trafo(self._entries[0].v) post_value = value_trafo(self._entries[-1].v) pw = TableEntry._sequence_as_expression(self._entries, expression_extractor=value_trafo, t=t, post_value=post_value, pre_value=pre_value) expressions[channel] = pw return expressions
def test_unknown_interpolation_strategy(self): with self.assertRaises(KeyError): TableEntry(0, 0, 'foo')
def test_slots(self): entry = TableEntry('a', Expression.make('b'), 'hold') self.assertFalse(hasattr(entry, '__dict__'))
def test_sequence_as_expression(self): def get_sympy(v): return v.sympified_expression t = sympy.Dummy('t') times = { t: 0.5, 't0': 0.3, 't1': 0.7, 't2': 1.3, } entries = [TableEntry(0, 0, None), TableEntry(1, 0, 'hold')] self.assertEqual( ExpressionScalar(0), TableEntry._sequence_as_expression( entries, get_sympy, t, pre_value=None, post_value=None).sympified_expression.subs(times)) entries = [TableEntry(0, 1, None), TableEntry(1, 1, 'hold')] self.assertEqual( ExpressionScalar(1), TableEntry._sequence_as_expression( entries, get_sympy, t, pre_value=None, post_value=None).sympified_expression.subs(times)) entries = [TableEntry(0, 0, None), TableEntry(1, 1, 'linear')] self.assertEqual( ExpressionScalar(.5), TableEntry._sequence_as_expression( entries, get_sympy, t, pre_value=None, post_value=None).sympified_expression.subs(times)) entries = [ TableEntry('t0', 'a', 'linear'), TableEntry('t1', 'b', 'linear'), TableEntry('t2', 'c', 'hold') ] self.assertEqual( ExpressionScalar('(a+b)*.5'), TableEntry._sequence_as_expression( entries, get_sympy, t, pre_value=None, post_value=None).sympified_expression.subs(times))
def test_sequence_integral(self): def get_sympy(v): return v.sympified_expression entries = [TableEntry(0, 0), TableEntry(1, 0, 'hold')] self.assertEqual(ExpressionScalar(0), TableEntry._sequence_integral(entries, get_sympy)) entries = [TableEntry(0, 1), TableEntry(1, 1, 'hold')] self.assertEqual(ExpressionScalar(1), TableEntry._sequence_integral(entries, get_sympy)) entries = [TableEntry(0, 0), TableEntry(1, 1, 'linear')] self.assertEqual(ExpressionScalar(.5), TableEntry._sequence_integral(entries, get_sympy)) entries = [ TableEntry('t0', 'a', 'linear'), TableEntry('t1', 'b', 'linear'), TableEntry('t2', 'c', 'hold') ] self.assertEqual(ExpressionScalar('(t1-t0)*(a+b)/2 + (t2-t1)*b'), TableEntry._sequence_integral(entries, get_sympy))