def test_init(self):
        """test init."""

        quadratic_program = QuadraticProgram()
        for _ in range(5):
            quadratic_program.continuous_var()
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 0)

        coefficients = np.array(range(5))

        # equality constraints
        quadratic_program.linear_constraint(sense="==")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 1)
        self.assertEqual(quadratic_program.linear_constraints[0].name, "c0")
        self.assertEqual(
            len(quadratic_program.linear_constraints[0].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[0].sense,
                         Constraint.Sense.EQ)
        self.assertEqual(quadratic_program.linear_constraints[0].rhs, 0.0)
        self.assertEqual(
            quadratic_program.linear_constraints[0],
            quadratic_program.get_linear_constraint("c0"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[0],
            quadratic_program.get_linear_constraint(0),
        )

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name="c0")

        quadratic_program.linear_constraint(coefficients, "==", 1.0, "c1")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 2)
        self.assertEqual(quadratic_program.linear_constraints[1].name, "c1")
        self.assertTrue(
            (quadratic_program.linear_constraints[1].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[1].sense,
                         Constraint.Sense.EQ)
        self.assertEqual(quadratic_program.linear_constraints[1].rhs, 1.0)
        self.assertEqual(
            quadratic_program.linear_constraints[1],
            quadratic_program.get_linear_constraint("c1"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[1],
            quadratic_program.get_linear_constraint(1),
        )

        # geq constraints
        quadratic_program.linear_constraint(sense=">=")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 3)
        self.assertEqual(quadratic_program.linear_constraints[2].name, "c2")
        self.assertEqual(
            len(quadratic_program.linear_constraints[2].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[2].sense,
                         Constraint.Sense.GE)
        self.assertEqual(quadratic_program.linear_constraints[2].rhs, 0.0)
        self.assertEqual(
            quadratic_program.linear_constraints[2],
            quadratic_program.get_linear_constraint("c2"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[2],
            quadratic_program.get_linear_constraint(2),
        )

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name="c2", sense=">=")

        quadratic_program.linear_constraint(coefficients, ">=", 1.0, "c3")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 4)
        self.assertEqual(quadratic_program.linear_constraints[3].name, "c3")
        self.assertTrue(
            (quadratic_program.linear_constraints[3].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[3].sense,
                         Constraint.Sense.GE)
        self.assertEqual(quadratic_program.linear_constraints[3].rhs, 1.0)
        self.assertEqual(
            quadratic_program.linear_constraints[3],
            quadratic_program.get_linear_constraint("c3"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[3],
            quadratic_program.get_linear_constraint(3),
        )

        # leq constraints
        quadratic_program.linear_constraint(sense="<=")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 5)
        self.assertEqual(quadratic_program.linear_constraints[4].name, "c4")
        self.assertEqual(
            len(quadratic_program.linear_constraints[4].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[4].sense,
                         Constraint.Sense.LE)
        self.assertEqual(quadratic_program.linear_constraints[4].rhs, 0.0)
        self.assertEqual(
            quadratic_program.linear_constraints[4],
            quadratic_program.get_linear_constraint("c4"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[4],
            quadratic_program.get_linear_constraint(4),
        )

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name="c4", sense="<=")

        quadratic_program.linear_constraint(coefficients, "<=", 1.0, "c5")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 6)
        self.assertEqual(quadratic_program.linear_constraints[5].name, "c5")
        self.assertTrue(
            (quadratic_program.linear_constraints[5].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[5].sense,
                         Constraint.Sense.LE)
        self.assertEqual(quadratic_program.linear_constraints[5].rhs, 1.0)
        self.assertEqual(
            quadratic_program.linear_constraints[5],
            quadratic_program.get_linear_constraint("c5"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[5],
            quadratic_program.get_linear_constraint(5),
        )
    def test_init(self):
        """ test init. """

        quadratic_program = QuadraticProgram()
        for _ in range(5):
            quadratic_program.continuous_var()
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 0)

        coefficients = np.array(range(5))

        # equality constraints
        quadratic_program.linear_constraint(sense='==')
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 1)
        self.assertEqual(quadratic_program.linear_constraints[0].name, 'c0')
        self.assertEqual(
            len(quadratic_program.linear_constraints[0].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[0].sense,
                         Constraint.Sense.EQ)
        self.assertEqual(quadratic_program.linear_constraints[0].rhs, 0.0)
        self.assertEqual(quadratic_program.linear_constraints[0],
                         quadratic_program.get_linear_constraint('c0'))
        self.assertEqual(quadratic_program.linear_constraints[0],
                         quadratic_program.get_linear_constraint(0))

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name='c0')

        quadratic_program.linear_constraint(coefficients, '==', 1.0, 'c1')
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 2)
        self.assertEqual(quadratic_program.linear_constraints[1].name, 'c1')
        self.assertTrue(
            (quadratic_program.linear_constraints[1].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[1].sense,
                         Constraint.Sense.EQ)
        self.assertEqual(quadratic_program.linear_constraints[1].rhs, 1.0)
        self.assertEqual(quadratic_program.linear_constraints[1],
                         quadratic_program.get_linear_constraint('c1'))
        self.assertEqual(quadratic_program.linear_constraints[1],
                         quadratic_program.get_linear_constraint(1))

        # geq constraints
        quadratic_program.linear_constraint(sense='>=')
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 3)
        self.assertEqual(quadratic_program.linear_constraints[2].name, 'c2')
        self.assertEqual(
            len(quadratic_program.linear_constraints[2].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[2].sense,
                         Constraint.Sense.GE)
        self.assertEqual(quadratic_program.linear_constraints[2].rhs, 0.0)
        self.assertEqual(quadratic_program.linear_constraints[2],
                         quadratic_program.get_linear_constraint('c2'))
        self.assertEqual(quadratic_program.linear_constraints[2],
                         quadratic_program.get_linear_constraint(2))

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name='c2', sense='>=')

        quadratic_program.linear_constraint(coefficients, '>=', 1.0, 'c3')
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 4)
        self.assertEqual(quadratic_program.linear_constraints[3].name, 'c3')
        self.assertTrue(
            (quadratic_program.linear_constraints[3].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[3].sense,
                         Constraint.Sense.GE)
        self.assertEqual(quadratic_program.linear_constraints[3].rhs, 1.0)
        self.assertEqual(quadratic_program.linear_constraints[3],
                         quadratic_program.get_linear_constraint('c3'))
        self.assertEqual(quadratic_program.linear_constraints[3],
                         quadratic_program.get_linear_constraint(3))

        # leq constraints
        quadratic_program.linear_constraint(sense='<=')
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 5)
        self.assertEqual(quadratic_program.linear_constraints[4].name, 'c4')
        self.assertEqual(
            len(quadratic_program.linear_constraints[4].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[4].sense,
                         Constraint.Sense.LE)
        self.assertEqual(quadratic_program.linear_constraints[4].rhs, 0.0)
        self.assertEqual(quadratic_program.linear_constraints[4],
                         quadratic_program.get_linear_constraint('c4'))
        self.assertEqual(quadratic_program.linear_constraints[4],
                         quadratic_program.get_linear_constraint(4))

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name='c4', sense='<=')

        quadratic_program.linear_constraint(coefficients, '<=', 1.0, 'c5')
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 6)
        self.assertEqual(quadratic_program.linear_constraints[5].name, 'c5')
        self.assertTrue(
            (quadratic_program.linear_constraints[5].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[5].sense,
                         Constraint.Sense.LE)
        self.assertEqual(quadratic_program.linear_constraints[5].rhs, 1.0)
        self.assertEqual(quadratic_program.linear_constraints[5],
                         quadratic_program.get_linear_constraint('c5'))
        self.assertEqual(quadratic_program.linear_constraints[5],
                         quadratic_program.get_linear_constraint(5))
Ejemplo n.º 3
0
    def test_linear_constraints_handling(self):
        """test linear constraints handling"""
        q_p = QuadraticProgram()
        q_p.binary_var("x")
        q_p.binary_var("y")
        q_p.binary_var("z")
        q_p.linear_constraint({"x": 1}, "==", 1)
        q_p.linear_constraint({"y": 1}, "<=", 1)
        q_p.linear_constraint({"z": 1}, ">=", 1)
        self.assertEqual(q_p.get_num_linear_constraints(), 3)
        lin = q_p.linear_constraints
        self.assertEqual(len(lin), 3)

        self.assertDictEqual(lin[0].linear.to_dict(), {0: 1})
        self.assertDictEqual(lin[0].linear.to_dict(use_name=True), {"x": 1})
        self.assertListEqual(lin[0].linear.to_array().tolist(), [1, 0, 0])
        self.assertEqual(lin[0].sense, Constraint.Sense.EQ)
        self.assertEqual(lin[0].rhs, 1)
        self.assertEqual(lin[0].name, "c0")
        self.assertEqual(q_p.get_linear_constraint(0).name, "c0")
        self.assertEqual(q_p.get_linear_constraint("c0").name, "c0")

        self.assertDictEqual(lin[1].linear.to_dict(), {1: 1})
        self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {"y": 1})
        self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 1, 0])
        self.assertEqual(lin[1].sense, Constraint.Sense.LE)
        self.assertEqual(lin[1].rhs, 1)
        self.assertEqual(lin[1].name, "c1")
        self.assertEqual(q_p.get_linear_constraint(1).name, "c1")
        self.assertEqual(q_p.get_linear_constraint("c1").name, "c1")

        self.assertDictEqual(lin[2].linear.to_dict(), {2: 1})
        self.assertDictEqual(lin[2].linear.to_dict(use_name=True), {"z": 1})
        self.assertListEqual(lin[2].linear.to_array().tolist(), [0, 0, 1])
        self.assertEqual(lin[2].sense, Constraint.Sense.GE)
        self.assertEqual(lin[2].rhs, 1)
        self.assertEqual(lin[2].name, "c2")
        self.assertEqual(q_p.get_linear_constraint(2).name, "c2")
        self.assertEqual(q_p.get_linear_constraint("c2").name, "c2")

        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(name="c0")
        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(name="c1")
        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(name="c2")
        with self.assertRaises(IndexError):
            q_p.get_linear_constraint(4)
        with self.assertRaises(KeyError):
            q_p.get_linear_constraint("c3")

        q_p.remove_linear_constraint("c1")
        lin = q_p.linear_constraints
        self.assertEqual(len(lin), 2)
        self.assertDictEqual(lin[1].linear.to_dict(), {2: 1})
        self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {"z": 1})
        self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 0, 1])
        self.assertEqual(lin[1].sense, Constraint.Sense.GE)
        self.assertEqual(lin[1].rhs, 1)
        self.assertEqual(lin[1].name, "c2")
        self.assertEqual(q_p.get_linear_constraint(1).name, "c2")
        self.assertEqual(q_p.get_linear_constraint("c2").name, "c2")

        with self.assertRaises(KeyError):
            q_p.remove_linear_constraint("c1")
        with self.assertRaises(IndexError):
            q_p.remove_linear_constraint(9)

        q_p.linear_constraint(sense="E")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ)
        q_p.linear_constraint(sense="G")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE)
        q_p.linear_constraint(sense="L")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE)
        q_p.linear_constraint(sense="EQ")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ)
        q_p.linear_constraint(sense="GE")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE)
        q_p.linear_constraint(sense="LE")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE)
        q_p.linear_constraint(sense="=")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ)
        q_p.linear_constraint(sense=">")
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE)
        q_p.linear_constraint(sense="<")

        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(sense="=>")
    def test_linear_constraints_handling(self):
        """test linear constraints handling"""
        q_p = QuadraticProgram()
        q_p.binary_var('x')
        q_p.binary_var('y')
        q_p.binary_var('z')
        q_p.linear_constraint({'x': 1}, '==', 1)
        q_p.linear_constraint({'y': 1}, '<=', 1)
        q_p.linear_constraint({'z': 1}, '>=', 1)
        self.assertEqual(q_p.get_num_linear_constraints(), 3)
        lin = q_p.linear_constraints
        self.assertEqual(len(lin), 3)

        self.assertDictEqual(lin[0].linear.to_dict(), {0: 1})
        self.assertDictEqual(lin[0].linear.to_dict(use_name=True), {'x': 1})
        self.assertListEqual(lin[0].linear.to_array().tolist(), [1, 0, 0])
        self.assertEqual(lin[0].sense, Constraint.Sense.EQ)
        self.assertEqual(lin[0].rhs, 1)
        self.assertEqual(lin[0].name, 'c0')
        self.assertEqual(q_p.get_linear_constraint(0).name, 'c0')
        self.assertEqual(q_p.get_linear_constraint('c0').name, 'c0')

        self.assertDictEqual(lin[1].linear.to_dict(), {1: 1})
        self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {'y': 1})
        self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 1, 0])
        self.assertEqual(lin[1].sense, Constraint.Sense.LE)
        self.assertEqual(lin[1].rhs, 1)
        self.assertEqual(lin[1].name, 'c1')
        self.assertEqual(q_p.get_linear_constraint(1).name, 'c1')
        self.assertEqual(q_p.get_linear_constraint('c1').name, 'c1')

        self.assertDictEqual(lin[2].linear.to_dict(), {2: 1})
        self.assertDictEqual(lin[2].linear.to_dict(use_name=True), {'z': 1})
        self.assertListEqual(lin[2].linear.to_array().tolist(), [0, 0, 1])
        self.assertEqual(lin[2].sense, Constraint.Sense.GE)
        self.assertEqual(lin[2].rhs, 1)
        self.assertEqual(lin[2].name, 'c2')
        self.assertEqual(q_p.get_linear_constraint(2).name, 'c2')
        self.assertEqual(q_p.get_linear_constraint('c2').name, 'c2')

        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(name='c0')
        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(name='c1')
        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(name='c2')
        with self.assertRaises(IndexError):
            q_p.get_linear_constraint(4)
        with self.assertRaises(KeyError):
            q_p.get_linear_constraint('c3')

        q_p.remove_linear_constraint('c1')
        lin = q_p.linear_constraints
        self.assertEqual(len(lin), 2)
        self.assertDictEqual(lin[1].linear.to_dict(), {2: 1})
        self.assertDictEqual(lin[1].linear.to_dict(use_name=True), {'z': 1})
        self.assertListEqual(lin[1].linear.to_array().tolist(), [0, 0, 1])
        self.assertEqual(lin[1].sense, Constraint.Sense.GE)
        self.assertEqual(lin[1].rhs, 1)
        self.assertEqual(lin[1].name, 'c2')
        self.assertEqual(q_p.get_linear_constraint(1).name, 'c2')
        self.assertEqual(q_p.get_linear_constraint('c2').name, 'c2')

        with self.assertRaises(KeyError):
            q_p.remove_linear_constraint('c1')
        with self.assertRaises(IndexError):
            q_p.remove_linear_constraint(9)

        q_p.linear_constraint(sense='E')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ)
        q_p.linear_constraint(sense='G')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE)
        q_p.linear_constraint(sense='L')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE)
        q_p.linear_constraint(sense='EQ')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ)
        q_p.linear_constraint(sense='GE')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE)
        q_p.linear_constraint(sense='LE')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.LE)
        q_p.linear_constraint(sense='=')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.EQ)
        q_p.linear_constraint(sense='>')
        self.assertEqual(q_p.linear_constraints[-1].sense, Constraint.Sense.GE)
        q_p.linear_constraint(sense='<')

        with self.assertRaises(QiskitOptimizationError):
            q_p.linear_constraint(sense='=>')
Ejemplo n.º 5
0
class TestLinearConstraint(QiskitOptimizationTestCase):
    """Test LinearConstraint."""
    def setUp(self) -> None:
        super().setUp()
        self.quadratic_program = QuadraticProgram()
        self.quadratic_program.binary_var_list(3, name="x")
        self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "<=", 1)
        self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "<", 1)
        self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "LE", 1)
        self.quadratic_program.linear_constraint({"x0": 1, "x1": -2}, "L", 1)
        self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "==", 2)
        self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "=", 2)
        self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "EQ", 2)
        self.quadratic_program.linear_constraint({"x0": -1, "x1": 2}, "E", 2)
        self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, ">=", 3)
        self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, ">", 3)
        self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, "GE", 3)
        self.quadratic_program.linear_constraint({"x1": 2, "x2": -1}, "G", 3)

    def test_init(self):
        """test init."""

        quadratic_program = QuadraticProgram()
        for _ in range(5):
            quadratic_program.continuous_var()
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 0)

        coefficients = np.array(range(5))

        # equality constraints
        quadratic_program.linear_constraint(sense="==")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 1)
        self.assertEqual(quadratic_program.linear_constraints[0].name, "c0")
        self.assertEqual(
            len(quadratic_program.linear_constraints[0].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[0].sense,
                         Constraint.Sense.EQ)
        self.assertEqual(quadratic_program.linear_constraints[0].rhs, 0.0)
        self.assertEqual(
            quadratic_program.linear_constraints[0],
            quadratic_program.get_linear_constraint("c0"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[0],
            quadratic_program.get_linear_constraint(0),
        )

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name="c0")

        quadratic_program.linear_constraint(coefficients, "==", 1.0, "c1")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 2)
        self.assertEqual(quadratic_program.linear_constraints[1].name, "c1")
        self.assertTrue(
            (quadratic_program.linear_constraints[1].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[1].sense,
                         Constraint.Sense.EQ)
        self.assertEqual(quadratic_program.linear_constraints[1].rhs, 1.0)
        self.assertEqual(
            quadratic_program.linear_constraints[1],
            quadratic_program.get_linear_constraint("c1"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[1],
            quadratic_program.get_linear_constraint(1),
        )

        # geq constraints
        quadratic_program.linear_constraint(sense=">=")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 3)
        self.assertEqual(quadratic_program.linear_constraints[2].name, "c2")
        self.assertEqual(
            len(quadratic_program.linear_constraints[2].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[2].sense,
                         Constraint.Sense.GE)
        self.assertEqual(quadratic_program.linear_constraints[2].rhs, 0.0)
        self.assertEqual(
            quadratic_program.linear_constraints[2],
            quadratic_program.get_linear_constraint("c2"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[2],
            quadratic_program.get_linear_constraint(2),
        )

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name="c2", sense=">=")

        quadratic_program.linear_constraint(coefficients, ">=", 1.0, "c3")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 4)
        self.assertEqual(quadratic_program.linear_constraints[3].name, "c3")
        self.assertTrue(
            (quadratic_program.linear_constraints[3].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[3].sense,
                         Constraint.Sense.GE)
        self.assertEqual(quadratic_program.linear_constraints[3].rhs, 1.0)
        self.assertEqual(
            quadratic_program.linear_constraints[3],
            quadratic_program.get_linear_constraint("c3"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[3],
            quadratic_program.get_linear_constraint(3),
        )

        # leq constraints
        quadratic_program.linear_constraint(sense="<=")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 5)
        self.assertEqual(quadratic_program.linear_constraints[4].name, "c4")
        self.assertEqual(
            len(quadratic_program.linear_constraints[4].linear.to_dict()), 0)
        self.assertEqual(quadratic_program.linear_constraints[4].sense,
                         Constraint.Sense.LE)
        self.assertEqual(quadratic_program.linear_constraints[4].rhs, 0.0)
        self.assertEqual(
            quadratic_program.linear_constraints[4],
            quadratic_program.get_linear_constraint("c4"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[4],
            quadratic_program.get_linear_constraint(4),
        )

        with self.assertRaises(QiskitOptimizationError):
            quadratic_program.linear_constraint(name="c4", sense="<=")

        quadratic_program.linear_constraint(coefficients, "<=", 1.0, "c5")
        self.assertEqual(quadratic_program.get_num_linear_constraints(), 6)
        self.assertEqual(quadratic_program.linear_constraints[5].name, "c5")
        self.assertTrue(
            (quadratic_program.linear_constraints[5].linear.to_array() ==
             coefficients).all())
        self.assertEqual(quadratic_program.linear_constraints[5].sense,
                         Constraint.Sense.LE)
        self.assertEqual(quadratic_program.linear_constraints[5].rhs, 1.0)
        self.assertEqual(
            quadratic_program.linear_constraints[5],
            quadratic_program.get_linear_constraint("c5"),
        )
        self.assertEqual(
            quadratic_program.linear_constraints[5],
            quadratic_program.get_linear_constraint(5),
        )

    def test_str(self):
        """Test str"""
        self.assertEqual(self.quadratic_program.get_num_linear_constraints(),
                         12)
        for i in range(0, 4):
            self.assertEqual(
                str(self.quadratic_program.get_linear_constraint(i)),
                f"x0 - 2*x1 <= 1 'c{i}'")
        for i in range(4, 8):
            self.assertEqual(
                str(self.quadratic_program.get_linear_constraint(i)),
                f"-x0 + 2*x1 == 2 'c{i}'")
        for i in range(8, 12):
            self.assertEqual(
                str(self.quadratic_program.get_linear_constraint(i)),
                f"2*x1 - x2 >= 3 'c{i}'")

    def test_repr(self):
        """Test repr"""
        self.assertEqual(self.quadratic_program.get_num_linear_constraints(),
                         12)
        for i in range(0, 4):
            self.assertEqual(
                repr(self.quadratic_program.get_linear_constraint(i)),
                f"<LinearConstraint: x0 - 2*x1 <= 1 'c{i}'>",
            )
        for i in range(4, 8):
            self.assertEqual(
                repr(self.quadratic_program.get_linear_constraint(i)),
                f"<LinearConstraint: -x0 + 2*x1 == 2 'c{i}'>",
            )
        for i in range(8, 12):
            self.assertEqual(
                repr(self.quadratic_program.get_linear_constraint(i)),
                f"<LinearConstraint: 2*x1 - x2 >= 3 'c{i}'>",
            )