Example #1
0
 def test_scalar_type_conversion(self):
     float_system = Adder(1, 1)
     float_context = float_system.CreateDefaultContext()
     float_system.get_input_port(0).FixValue(float_context, 1.)
     for T in [float, AutoDiffXd, Expression]:
         system = Adder_[T](1, 1)
         # N.B. Current scalar conversion does not permit conversion to and
         # from the same type.
         if T != AutoDiffXd:
             methods = [Adder_[T].ToAutoDiffXd, Adder_[T].ToAutoDiffXdMaybe]
             for method in methods:
                 system_ad = method(system)
                 self.assertIsInstance(system_ad, System_[AutoDiffXd])
                 self._compare_system_instances(system, system_ad)
         if T != Expression:
             methods = [Adder_[T].ToSymbolic, Adder_[T].ToSymbolicMaybe]
             for method in methods:
                 system_sym = method(system)
                 self.assertIsInstance(system_sym, System_[Expression])
                 self._compare_system_instances(system, system_sym)
         context = system.CreateDefaultContext()
         system.FixInputPortsFrom(other_system=float_system,
                                  other_context=float_context,
                                  target_context=context)
         u = system.get_input_port(0).Eval(context)
         self.assertEqual(len(u), 1)
         if T == float:
             self.assertEqual(u[0], 1.)
         elif T == AutoDiffXd:
             self.assertEqual(u[0].value(), 1.)
         else:
             self.assertEqual(u[0].Evaluate(), 1.)
Example #2
0
    def test_context_api(self):
        system = Adder(3, 10)
        context = system.CreateDefaultContext()
        self.assertIsInstance(context.get_continuous_state(), ContinuousState)
        self.assertIsInstance(context.get_mutable_continuous_state(),
                              ContinuousState)
        self.assertIsInstance(context.get_continuous_state_vector(),
                              VectorBase)
        self.assertIsInstance(context.get_mutable_continuous_state_vector(),
                              VectorBase)
        # TODO(eric.cousineau): Consolidate main API tests for `Context` here.

        pendulum = PendulumPlant()
        context = pendulum.CreateDefaultContext()
        self.assertEqual(context.num_numeric_parameter_groups(), 1)
        self.assertTrue(context.get_parameters().get_numeric_parameter(0) is
                        context.get_numeric_parameter(index=0))
        self.assertEqual(context.num_abstract_parameters(), 0)
        # TODO(russt): Bind _Declare*Parameter or find an example with an
        # abstract parameter to actually call this method.
        self.assertTrue(hasattr(context, "get_abstract_parameter"))
        x = np.array([0.1, 0.2])
        context.SetContinuousState(x)
        np.testing.assert_equal(
            context.get_continuous_state_vector().CopyToVector(), x)
Example #3
0
 def test_system_base_api(self):
     # Test a system with a different number of inputs from outputs.
     system = Adder(3, 10)
     self.assertEqual(system.get_num_input_ports(), 3)
     self.assertEqual(system.get_num_output_ports(), 1)
     # Test deprecated methods.
     context = system.CreateDefaultContext()
     with warnings.catch_warnings(record=True) as w:
         c = system.AllocateOutput(context)
         self.assertEqual(len(w), 1)
Example #4
0
 def test_context_api(self):
     system = Adder(3, 10)
     context = system.CreateDefaultContext()
     self.assertIsInstance(context.get_continuous_state(), ContinuousState)
     self.assertIsInstance(context.get_mutable_continuous_state(),
                           ContinuousState)
     self.assertIsInstance(context.get_continuous_state_vector(),
                           VectorBase)
     self.assertIsInstance(context.get_mutable_continuous_state_vector(),
                           VectorBase)
Example #5
0
 def test_ownership_vector(self):
     system = Adder(1, 1)
     context = system.CreateDefaultContext()
     info = Info()
     vector = DeleteListenerVector(info.record_deletion)
     context.FixInputPort(0, vector)
     del context
     # WARNING
     self.assertTrue(info.deleted)
     self.assertTrue(vector is not None)
Example #6
0
 def test_ownership_vector(self):
     system = Adder(1, 1)
     context = system.CreateDefaultContext()
     info = Info()
     vector = DeleteListenerVector(info.record_deletion)
     context.FixInputPort(0, vector)
     del context
     # Same as above applications, using `py::keep_alive`.
     self.assertFalse(info.deleted)
     self.assertTrue(vector is not None)
     # Ensure that we do not get segfault behavior when accessing / mutating
     # the values.
     self.assertTrue(np.allclose(vector.get_value(), [0.]))
     vector.get_mutable_value()[:] = [10.]
     self.assertTrue(np.allclose(vector.get_value(), [10.]))
Example #7
0
    def test_context_api(self):
        system = Adder(3, 10)
        context = system.CreateDefaultContext()
        self.assertIsInstance(
            context.get_continuous_state(), ContinuousState)
        self.assertIsInstance(
            context.get_mutable_continuous_state(), ContinuousState)
        self.assertIsInstance(
            context.get_continuous_state_vector(), VectorBase)
        self.assertIsInstance(
            context.get_mutable_continuous_state_vector(), VectorBase)
        # TODO(eric.cousineau): Consolidate main API tests for `Context` here.

        pendulum = PendulumPlant()
        context = pendulum.CreateDefaultContext()
        self.assertEqual(context.num_numeric_parameter_groups(), 1)
        self.assertEqual(pendulum.num_numeric_parameter_groups(), 1)
        self.assertTrue(
            context.get_parameters().get_numeric_parameter(0) is
            context.get_numeric_parameter(index=0))
        self.assertEqual(context.num_abstract_parameters(), 0)
        self.assertEqual(pendulum.num_numeric_parameter_groups(), 1)
        # TODO(russt): Bind _Declare*Parameter or find an example with an
        # abstract parameter to actually call this method.
        self.assertTrue(hasattr(context, "get_abstract_parameter"))
        x = np.array([0.1, 0.2])
        context.SetContinuousState(x)
        np.testing.assert_equal(
            context.get_continuous_state_vector().CopyToVector(), x)

        # RimlessWheel has a single discrete variable and a bool abstract
        # variable.
        rimless = RimlessWheel()
        context = rimless.CreateDefaultContext()
        x = np.array([1.125])
        context.SetDiscreteState(xd=2 * x)
        np.testing.assert_equal(
            context.get_discrete_state_vector().CopyToVector(), 2 * x)
        context.SetDiscreteState(group_index=0, xd=3 * x)
        np.testing.assert_equal(
            context.get_discrete_state_vector().CopyToVector(), 3 * x)

        context.SetAbstractState(index=0, value=True)
        value = context.get_abstract_state(0)
        self.assertTrue(value.get_value())
        context.SetAbstractState(index=0, value=False)
        value = context.get_abstract_state(0)
        self.assertFalse(value.get_value())
Example #8
0
    def test_context_api(self):
        system = Adder(3, 10)
        context = system.AllocateContext()
        self.assertIsInstance(
            context.get_continuous_state(), ContinuousState)
        self.assertIsInstance(
            context.get_mutable_continuous_state(), ContinuousState)
        self.assertIsInstance(
            context.get_continuous_state_vector(), VectorBase)
        self.assertIsInstance(
            context.get_mutable_continuous_state_vector(), VectorBase)
        system.SetDefaultContext(context)

        # Check random context method.
        system.SetRandomContext(context=context, generator=RandomGenerator())

        context = system.CreateDefaultContext()
        self.assertIsInstance(
            context.get_continuous_state(), ContinuousState)
        self.assertIsInstance(
            context.get_mutable_continuous_state(), ContinuousState)
        self.assertIsInstance(
            context.get_continuous_state_vector(), VectorBase)
        self.assertIsInstance(
            context.get_mutable_continuous_state_vector(), VectorBase)
        self.assertTrue(context.is_stateless())
        self.assertFalse(context.has_only_continuous_state())
        self.assertFalse(context.has_only_discrete_state())
        self.assertEqual(context.num_total_states(), 0)
        # TODO(eric.cousineau): Consolidate main API tests for `Context` here.

        # Test methods with two scalar types.
        for T in [float, AutoDiffXd, Expression]:
            systemT = Adder_[T](3, 10)
            contextT = systemT.CreateDefaultContext()
            for U in [float, AutoDiffXd, Expression]:
                systemU = Adder_[U](3, 10)
                contextU = systemU.CreateDefaultContext()
                contextU.SetTime(0.5)
                contextT.SetTimeStateAndParametersFrom(contextU)
                if T == float:
                    self.assertEqual(contextT.get_time(), 0.5)
                elif T == AutoDiffXd:
                    self.assertEqual(contextT.get_time().value(), 0.5)
                else:
                    self.assertEqual(contextT.get_time().Evaluate(), 0.5)

        pendulum = PendulumPlant()
        context = pendulum.CreateDefaultContext()
        self.assertEqual(context.num_numeric_parameter_groups(), 1)
        self.assertEqual(pendulum.num_numeric_parameter_groups(), 1)
        self.assertTrue(
            context.get_parameters().get_numeric_parameter(0) is
            context.get_numeric_parameter(index=0))
        self.assertTrue(
            context.get_mutable_parameters().get_mutable_numeric_parameter(
                0) is context.get_mutable_numeric_parameter(index=0))
        self.assertEqual(context.num_abstract_parameters(), 0)
        self.assertEqual(pendulum.num_numeric_parameter_groups(), 1)
        # TODO(russt): Bind _Declare*Parameter or find an example with an
        # abstract parameter to actually call this method.
        self.assertTrue(hasattr(context, "get_abstract_parameter"))
        self.assertTrue(hasattr(context, "get_mutable_abstract_parameter"))
        context.DisableCaching()
        context.EnableCaching()
        context.SetAllCacheEntriesOutOfDate()
        context.FreezeCache()
        self.assertTrue(context.is_cache_frozen())
        context.UnfreezeCache()
        self.assertFalse(context.is_cache_frozen())
        x = np.array([0.1, 0.2])
        context.SetContinuousState(x)
        np.testing.assert_equal(
            context.get_continuous_state().CopyToVector(), x)
        np.testing.assert_equal(
            context.get_continuous_state_vector().CopyToVector(), x)
        context.SetTimeAndContinuousState(0.3, 2*x)
        np.testing.assert_equal(context.get_time(), 0.3)
        np.testing.assert_equal(
            context.get_continuous_state_vector().CopyToVector(), 2*x)
        self.assertNotEqual(pendulum.EvalPotentialEnergy(context=context), 0)
        self.assertNotEqual(pendulum.EvalKineticEnergy(context=context), 0)

        # RimlessWheel has a single discrete variable and a bool abstract
        # variable.
        rimless = RimlessWheel()
        context = rimless.CreateDefaultContext()
        x = np.array([1.125])
        context.SetDiscreteState(xd=2 * x)
        np.testing.assert_equal(
            context.get_discrete_state_vector().CopyToVector(), 2 * x)
        context.SetDiscreteState(group_index=0, xd=3 * x)
        np.testing.assert_equal(
            context.get_discrete_state_vector().CopyToVector(), 3 * x)

        def check_abstract_value_zero(context, expected_value):
            # Check through Context, State, and AbstractValues APIs.
            self.assertEqual(context.get_abstract_state(index=0).get_value(),
                             expected_value)
            self.assertEqual(context.get_abstract_state().get_value(
                index=0).get_value(), expected_value)
            self.assertEqual(context.get_state().get_abstract_state()
                             .get_value(index=0).get_value(), expected_value)

        context.SetAbstractState(index=0, value=True)
        check_abstract_value_zero(context, True)
        context.SetAbstractState(index=0, value=False)
        check_abstract_value_zero(context, False)
        value = context.get_mutable_state().get_mutable_abstract_state()\
            .get_mutable_value(index=0)
        value.set_value(True)
        check_abstract_value_zero(context, True)
Example #9
0
    def test_context_api(self):
        system = Adder(3, 10)
        context = system.AllocateContext()
        self.assertIsInstance(context.get_continuous_state(), ContinuousState)
        self.assertIsInstance(context.get_mutable_continuous_state(),
                              ContinuousState)
        self.assertIsInstance(context.get_continuous_state_vector(),
                              VectorBase)
        self.assertIsInstance(context.get_mutable_continuous_state_vector(),
                              VectorBase)

        context = system.CreateDefaultContext()
        self.assertIsInstance(context.get_continuous_state(), ContinuousState)
        self.assertIsInstance(context.get_mutable_continuous_state(),
                              ContinuousState)
        self.assertIsInstance(context.get_continuous_state_vector(),
                              VectorBase)
        self.assertIsInstance(context.get_mutable_continuous_state_vector(),
                              VectorBase)
        # TODO(eric.cousineau): Consolidate main API tests for `Context` here.

        # Test methods with two scalar types.
        for T in [float, AutoDiffXd, Expression]:
            systemT = Adder_[T](3, 10)
            contextT = systemT.CreateDefaultContext()
            for U in [float, AutoDiffXd, Expression]:
                systemU = Adder_[U](3, 10)
                contextU = systemU.CreateDefaultContext()
                contextU.SetTime(0.5)
                contextT.SetTimeStateAndParametersFrom(contextU)
                if T == float:
                    self.assertEqual(contextT.get_time(), 0.5)
                elif T == AutoDiffXd:
                    self.assertEqual(contextT.get_time().value(), 0.5)
                else:
                    self.assertEqual(contextT.get_time().Evaluate(), 0.5)

        pendulum = PendulumPlant()
        context = pendulum.CreateDefaultContext()
        self.assertEqual(context.num_numeric_parameter_groups(), 1)
        self.assertEqual(pendulum.num_numeric_parameter_groups(), 1)
        self.assertTrue(context.get_parameters().get_numeric_parameter(0) is
                        context.get_numeric_parameter(index=0))
        self.assertEqual(context.num_abstract_parameters(), 0)
        self.assertEqual(pendulum.num_numeric_parameter_groups(), 1)
        # TODO(russt): Bind _Declare*Parameter or find an example with an
        # abstract parameter to actually call this method.
        self.assertTrue(hasattr(context, "get_abstract_parameter"))
        x = np.array([0.1, 0.2])
        context.SetContinuousState(x)
        np.testing.assert_equal(
            context.get_continuous_state_vector().CopyToVector(), x)

        # RimlessWheel has a single discrete variable and a bool abstract
        # variable.
        rimless = RimlessWheel()
        context = rimless.CreateDefaultContext()
        x = np.array([1.125])
        context.SetDiscreteState(xd=2 * x)
        np.testing.assert_equal(
            context.get_discrete_state_vector().CopyToVector(), 2 * x)
        context.SetDiscreteState(group_index=0, xd=3 * x)
        np.testing.assert_equal(
            context.get_discrete_state_vector().CopyToVector(), 3 * x)

        context.SetAbstractState(index=0, value=True)
        value = context.get_abstract_state(0)
        self.assertTrue(value.get_value())
        context.SetAbstractState(index=0, value=False)
        value = context.get_abstract_state(0)
        self.assertFalse(value.get_value())