BUILD.bazel

# -*- python -*-

load(
    "@drake//tools/skylark:drake_cc.bzl",
    "drake_cc_binary",
    "drake_cc_googletest",
    "drake_cc_library",
    "drake_cc_package_library",
    "drake_cc_test",
)
load(
    "@drake//tools/skylark:test_tags.bzl",
    "gurobi_test_tags",
    "mosek_test_tags",
)
load("//tools/lint:lint.bzl", "add_lint_tests")

package(default_visibility = ["//visibility:public"])

drake_cc_package_library(
    name = "solvers",
    deps = [
        ":bilinear_product_util",
        ":binding",
        ":branch_and_bound",
        ":choose_best_solver",
        ":constraint",
        ":cost",
        ":create_constraint",
        ":create_cost",
        ":csdp_solver",
        ":decision_variable",
        ":dreal_solver",
        ":equality_constrained_qp_solver",
        ":evaluator_base",
        ":function",
        ":gurobi_qp",
        ":gurobi_solver",
        ":indeterminate",
        ":integer_inequality_solver",
        ":integer_optimization_util",
        ":ipopt_solver",
        ":linear_system_solver",
        ":mathematical_program",
        ":mathematical_program_result",
        ":minimum_value_constraint",
        ":mixed_integer_optimization_util",
        ":mixed_integer_rotation_constraint",
        ":moby_lcp_solver",
        ":mosek_solver",
        ":nlopt_solver",
        ":non_convex_optimization_util",
        ":osqp_solver",
        ":program_attribute",
        ":rotation_constraint",
        ":scs_solver",
        ":sdpa_free_format",
        ":snopt_solver",
        ":solution_result",
        ":solve",
        ":solver_base",
        ":solver_id",
        ":solver_interface",
        ":solver_options",
        ":solver_type",
        ":solver_type_converter",
        ":sos_basis_generator",
        ":symbolic_extraction",
        ":system_identification",
        ":unrevised_lemke_solver",
    ],
)

drake_cc_library(
    name = "integer_inequality_solver",
    srcs = ["integer_inequality_solver.cc"],
    hdrs = ["integer_inequality_solver.h"],
    deps = ["//common:essential"],
)

drake_cc_library(
    name = "sos_basis_generator",
    srcs = ["sos_basis_generator.cc"],
    hdrs = ["sos_basis_generator.h"],
    deps = [
        ":integer_inequality_solver",
        "//common:essential",
        "//common:polynomial",
        "//common:symbolic",
    ],
)

drake_cc_library(
    name = "binding",
    srcs = [],
    hdrs = ["binding.h"],
    deps = [
        ":decision_variable",
    ],
)

drake_cc_library(
    name = "choose_best_solver",
    srcs = ["choose_best_solver.cc"],
    hdrs = ["choose_best_solver.h"],
    deps = [
        ":csdp_solver",
        ":equality_constrained_qp_solver",
        ":gurobi_solver",
        ":ipopt_solver",
        ":linear_system_solver",
        ":mathematical_program",
        ":moby_lcp_solver",
        ":mosek_solver",
        ":nlopt_solver",
        ":osqp_solver",
        ":scs_solver",
        ":snopt_solver",
        ":solver_id",
    ],
)

drake_cc_library(
    name = "evaluator_base",
    srcs = ["evaluator_base.cc"],
    hdrs = ["evaluator_base.h"],
    deps = [
        ":function",
        "//common:autodiff",
        "//common:essential",
        "//common:nice_type_name",
        "//common:polynomial",
        "//common:symbolic",
        "//math:autodiff",
        "//math:matrix_util",
    ],
)

drake_cc_library(
    name = "constraint",
    srcs = ["constraint.cc"],
    hdrs = ["constraint.h"],
    deps = [
        ":decision_variable",
        ":evaluator_base",
        ":symbolic_extraction",
        "//common:autodiff",
        "//common:essential",
        "//common:polynomial",
        "//common:symbolic",
        "//math:matrix_util",
    ],
)

drake_cc_library(
    name = "minimum_value_constraint",
    srcs = ["minimum_value_constraint.cc"],
    hdrs = ["minimum_value_constraint.h"],
    deps = [
        ":constraint",
        "//math:gradient",
    ],
)

drake_cc_library(
    name = "cost",
    srcs = ["cost.cc"],
    hdrs = ["cost.h"],
    deps = [
        ":evaluator_base",
        "//common:autodiff",
        "//common:essential",
        "//common:polynomial",
        "//math:matrix_util",
    ],
)

drake_cc_library(
    name = "symbolic_extraction",
    srcs = ["symbolic_extraction.cc"],
    hdrs = ["symbolic_extraction.h"],
    deps = [
        ":decision_variable",
        "//common:autodiff",
        "//common:essential",
        "//common:polynomial",
        "//common:symbolic",
        "//math:matrix_util",
    ],
)

drake_cc_library(
    name = "create_constraint",
    srcs = ["create_constraint.cc"],
    hdrs = ["create_constraint.h"],
    deps = [
        ":binding",
        ":constraint",
        ":symbolic_extraction",
        "//common:essential",
        "//common:polynomial",
        "//common:symbolic",
        "//math:quadratic_form",
    ],
)

drake_cc_library(
    name = "create_cost",
    srcs = ["create_cost.cc"],
    hdrs = ["create_cost.h"],
    deps = [
        ":binding",
        ":cost",
        ":symbolic_extraction",
        "//common:essential",
        "//common:polynomial",
        "//common:symbolic",
        "//common:unused",
    ],
)

drake_cc_library(
    name = "decision_variable",
    srcs = ["decision_variable.cc"],
    hdrs = ["decision_variable.h"],
    deps = [
        "//common:symbolic",
    ],
)

drake_cc_library(
    name = "function",
    srcs = [],
    hdrs = ["function.h"],
    deps = [
        "//common:essential",
    ],
)

drake_cc_library(
    name = "solver_type",
    hdrs = ["solver_type.h"],
)

drake_cc_library(
    name = "solver_id",
    srcs = ["solver_id.cc"],
    hdrs = ["solver_id.h"],
    deps = [
        "//common:essential",
        "//common:hash",
        "//common:reset_after_move",
    ],
)

drake_cc_library(
    name = "solver_options",
    srcs = ["solver_options.cc"],
    hdrs = ["solver_options.h"],
    deps = [
        ":solver_id",
    ],
)

drake_cc_library(
    name = "indeterminate",
    srcs = ["indeterminate.cc"],
    hdrs = ["indeterminate.h"],
    deps = [
        "//common:symbolic",
        "//solvers:decision_variable",
    ],
)

drake_cc_library(
    name = "solver_type_converter",
    srcs = ["solver_type_converter.cc"],
    hdrs = ["solver_type_converter.h"],
    deps = [
        ":csdp_solver",
        ":dreal_solver",
        ":equality_constrained_qp_solver",
        ":gurobi_solver",
        ":ipopt_solver",
        ":linear_system_solver",
        ":moby_lcp_solver",
        ":mosek_solver",
        ":nlopt_solver",
        ":osqp_solver",
        ":scs_solver",
        ":snopt_solver",
        ":solver_id",
        ":solver_type",
        ":unrevised_lemke_solver",
        "//common:essential",
    ],
)

drake_cc_library(
    name = "mathematical_program",
    srcs = [
        "mathematical_program.cc",
    ],
    hdrs = [
        "mathematical_program.h",
    ],
    deps = [
        ":binding",
        ":create_constraint",
        ":create_cost",
        ":decision_variable",
        ":function",
        ":indeterminate",
        ":mathematical_program_result",
        ":program_attribute",
        ":solution_result",
        ":solver_id",
        ":solver_options",
        ":sos_basis_generator",
        ":symbolic_extraction",
        "//common:autodiff",
        "//common:essential",
        "//common:polynomial",
        "//common:symbolic",
    ],
)

drake_cc_library(
    name = "mathematical_program_result",
    srcs = ["mathematical_program_result.cc"],
    hdrs = ["mathematical_program_result.h"],
    deps = [
        ":binding",
        ":solution_result",
        ":solver_id",
        "//common:symbolic",
        "//common:value",
    ],
)

drake_cc_library(
    name = "solver_interface",
    srcs = [
        "solver_interface.cc",
    ],
    hdrs = [
        "solver_interface.h",
    ],
    deps = [
        ":mathematical_program",
        ":mathematical_program_result",
        ":solution_result",
        ":solver_id",
        ":solver_options",
        "//common:essential",
    ],
)

drake_cc_library(
    name = "branch_and_bound",
    srcs = ["branch_and_bound.cc"],
    hdrs = ["branch_and_bound.h"],
    deps = [
        ":gurobi_solver",
        ":mathematical_program",
        ":scs_solver",
    ],
)

drake_cc_library(
    name = "non_convex_optimization_util",
    srcs = ["non_convex_optimization_util.cc"],
    hdrs = ["non_convex_optimization_util.h"],
    deps = [
        ":mathematical_program",
        ":solve",
        "//math:quadratic_form",
    ],
)

drake_cc_library(
    name = "bilinear_product_util",
    srcs = ["bilinear_product_util.cc"],
    hdrs = ["bilinear_product_util.h"],
    deps = [
        ":decision_variable",
        "//common:essential",
        "//common:symbolic",
    ],
)

drake_cc_library(
    name = "integer_optimization_util",
    srcs = ["integer_optimization_util.cc"],
    hdrs = ["integer_optimization_util.h"],
    deps = [
        ":create_constraint",
    ],
)

drake_cc_library(
    name = "system_identification",
    srcs = ["system_identification.cc"],
    hdrs = ["system_identification.h"],
    deps = [
        ":mathematical_program",
        ":solve",
        "//common:autodiff",
        "//common:essential",
        "//common:polynomial",
    ],
)

drake_cc_library(
    name = "rotation_constraint",
    srcs = [
        "rotation_constraint.cc",
    ],
    hdrs = [
        "rotation_constraint.h",
    ],
    deps = [
        ":mathematical_program",
        "//math:gradient",
    ],
)

drake_cc_library(
    name = "mixed_integer_rotation_constraint",
    srcs = [
        "mixed_integer_rotation_constraint.cc",
        "mixed_integer_rotation_constraint_internal.cc",
    ],
    hdrs = [
        "mixed_integer_rotation_constraint.h",
        "mixed_integer_rotation_constraint_internal.h",
    ],
    deps = [
        ":bilinear_product_util",
        ":integer_optimization_util",
        ":mathematical_program",
        ":mixed_integer_optimization_util",
        ":solve",
    ],
)

drake_cc_library(
    name = "program_attribute",
    srcs = ["program_attribute.cc"],
    hdrs = ["program_attribute.h"],
    deps = [
        "//common:hash",
    ],
)

drake_cc_library(
    name = "rotation_constraint_visualization",
    testonly = 1,
    srcs = [
        "test/rotation_constraint_visualization.cc",
    ],
    hdrs = [
        "test/rotation_constraint_visualization.h",
    ],
    deps = [
        ":mixed_integer_rotation_constraint",
        ":rotation_constraint",
        "//common/proto:call_python",
    ],
)

drake_cc_library(
    name = "add_solver_util",
    testonly = 1,
    srcs = ["test/add_solver_util.cc"],
    hdrs = ["test/add_solver_util.h"],
    deps = [
        ":mathematical_program",
        ":solver_interface",
    ],
)

drake_cc_library(
    name = "generic_trivial_cost",
    testonly = 1,
    srcs = [],
    hdrs = ["test/generic_trivial_costs.h"],
    deps = [
        ":constraint",
        ":cost",
    ],
)

drake_cc_library(
    name = "generic_trivial_constraint",
    testonly = 1,
    srcs = [],
    hdrs = ["test/generic_trivial_constraints.h"],
    deps = [
        ":constraint",
    ],
)

drake_cc_googletest(
    name = "indeterminate_test",
    deps = [
        ":indeterminate",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_library(
    name = "mathematical_program_test_util",
    testonly = 1,
    srcs = ["test/mathematical_program_test_util.cc"],
    hdrs = ["test/mathematical_program_test_util.h"],
    deps = [
        ":mathematical_program",
        ":solver_interface",
        "@gtest//:without_main",
    ],
)

drake_cc_library(
    name = "optimization_examples",
    testonly = 1,
    srcs = ["test/optimization_examples.cc"],
    hdrs = ["test/optimization_examples.h"],
    deps = [
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":solver_type_converter",
        "//common/test_utilities:eigen_matrix_compare",
        "@gtest//:without_main",
    ],
)

drake_cc_library(
    name = "linear_program_examples",
    testonly = 1,
    srcs = ["test/linear_program_examples.cc"],
    hdrs = ["test/linear_program_examples.h"],
    deps = [
        ":optimization_examples",
        ":solver_interface",
    ],
)

drake_cc_library(
    name = "quadratic_program_examples",
    testonly = 1,
    srcs = ["test/quadratic_program_examples.cc"],
    hdrs = ["test/quadratic_program_examples.h"],
    deps = [
        ":optimization_examples",
    ],
)

drake_cc_library(
    name = "second_order_cone_program_examples",
    testonly = 1,
    srcs = ["test/second_order_cone_program_examples.cc"],
    hdrs = ["test/second_order_cone_program_examples.h"],
    deps = [
        ":mathematical_program_test_util",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_library(
    name = "semidefinite_program_examples",
    testonly = 1,
    srcs = ["test/semidefinite_program_examples.cc"],
    hdrs = ["test/semidefinite_program_examples.h"],
    deps = [
        ":mathematical_program_test_util",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_library(
    name = "exponential_cone_program_examples",
    testonly = 1,
    srcs = ["test/exponential_cone_program_examples.cc"],
    hdrs = ["test/exponential_cone_program_examples.h"],
    deps = [
        ":mathematical_program_test_util",
        ":solver_interface",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_library(
    name = "solution_result",
    srcs = [
        "solution_result.cc",
    ],
    hdrs = ["solution_result.h"],
)

drake_cc_library(
    name = "solver_base",
    srcs = [
        "solver_base.cc",
    ],
    hdrs = [
        "solver_base.h",
    ],
    deps = [
        ":mathematical_program",
        ":solver_interface",
    ],
)

drake_cc_library(
    name = "solve",
    srcs = ["solve.cc"],
    hdrs = ["solve.h"],
    deps = [
        ":choose_best_solver",
        ":mathematical_program",
        "//common:nice_type_name",
    ],
)

# Internal Solvers.

drake_cc_library(
    name = "equality_constrained_qp_solver",
    srcs = ["equality_constrained_qp_solver.cc"],
    hdrs = ["equality_constrained_qp_solver.h"],
    deps = [
        ":mathematical_program",
        ":solver_base",
        "//common:essential",
    ],
)

drake_cc_library(
    name = "linear_system_solver",
    srcs = ["linear_system_solver.cc"],
    hdrs = ["linear_system_solver.h"],
    deps = [
        ":mathematical_program",
        ":solver_base",
        "//common:essential",
    ],
)

drake_cc_library(
    name = "unrevised_lemke_solver",
    srcs = ["unrevised_lemke_solver.cc"],
    hdrs = ["unrevised_lemke_solver.h"],
    deps = [
        ":mathematical_program",
        ":solver_base",
        "//common:default_scalars",
        "//common:essential",
    ],
)

drake_cc_library(
    name = "moby_lcp_solver",
    srcs = ["moby_lcp_solver.cc"],
    hdrs = ["moby_lcp_solver.h"],
    deps = [
        ":mathematical_program",
        ":solver_base",
        "//common:essential",
    ],
)

drake_cc_library(
    name = "dreal_solver",
    srcs = select({
        "//tools:no_dreal": [
            "dreal_solver_common.cc",
            "no_dreal.cc",
        ],
        "//conditions:default": [
            "dreal_solver.cc",
            "dreal_solver_common.cc",
        ],
    }),
    hdrs = ["dreal_solver.h"],
    deps = select({
        "//conditions:default": [
            ":mathematical_program",
            ":solver_base",
            "//common:essential",
            "@dreal//dreal/api",
        ],
        "//tools:no_dreal": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

# External Solvers.

# If --config gurobi is used, this target builds object code that satisfies
# SolverInterface by calling Gurobi. Otherwise, this target builds dummy object
# code that fails at runtime.
drake_cc_library(
    name = "gurobi_solver",
    srcs = select({
        "//tools:with_gurobi": [
            "gurobi_solver.cc",
            "gurobi_solver_common.cc",
        ],
        "//conditions:default": [
            "gurobi_solver_common.cc",
            "no_gurobi.cc",
        ],
    }),
    hdrs = ["gurobi_solver.h"],
    deps = select({
        "//tools:with_gurobi": [
            ":mathematical_program",
            ":solver_base",
            "//math:eigen_sparse_triplet",
            "//common:scope_exit",
            "//common:scoped_singleton",
            "@gurobi//:gurobi_c",
            "@fmt",
        ],
        "//conditions:default": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

# If --config mosek is used, this target builds object code that satisfies
# SolverInterface by calling MOSEK. Otherwise, this target builds dummy object
# code that fails at runtime.
drake_cc_library(
    name = "mosek_solver",
    srcs = select({
        "//tools:with_mosek": [
            "mosek_solver.cc",
            "mosek_solver_common.cc",
        ],
        "//conditions:default": [
            "mosek_solver_common.cc",
            "no_mosek.cc",
        ],
    }),
    hdrs = ["mosek_solver.h"],
    deps = select({
        "//tools:with_mosek": [
            ":mathematical_program",
            ":mathematical_program_result",
            ":solver_base",
            "//common:scoped_singleton",
            "@mosek",
        ],
        "//conditions:default": [
            ":mathematical_program",
            ":mathematical_program_result",
            ":solver_base",
        ],
    }),
)

# If --config snopt is used, this target builds object code that satisfies
# SolverInterface by calling SNOPT. Otherwise, this target builds dummy object
# code that fails at runtime.
drake_cc_library(
    name = "snopt_solver",
    srcs = select({
        "//tools:with_snopt": [
            "snopt_solver.cc",
            "snopt_solver_common.cc",
        ],
        "//conditions:default": [
            "no_snopt.cc",
            "snopt_solver_common.cc",
        ],
    }),
    hdrs = ["snopt_solver.h"],
    copts = select({
        "//tools:with_snopt_fortran": [
            "-DWITH_SNOPT_FORTRAN=1",
        ],
        "//conditions:default": [],
    }),
    deps = select({
        "//tools:with_snopt": [
            ":mathematical_program",
            ":solver_base",
            "//common:scope_exit",
            "//math:autodiff",
            "@snopt//:snopt_cwrap",
        ],
        "//conditions:default": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

drake_cc_library(
    name = "ipopt_solver",
    srcs = select({
        "//tools:no_ipopt": [
            "ipopt_solver_common.cc",
            "no_ipopt.cc",
        ],
        "//conditions:default": [
            "ipopt_solver.cc",
            "ipopt_solver_common.cc",
        ],
    }),
    hdrs = ["ipopt_solver.h"],
    deps = select({
        "//conditions:default": [
            "@ipopt",
            ":mathematical_program",
            ":solver_base",
            "//common:unused",
            "//math:autodiff",
        ],
        "//tools:no_ipopt": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

drake_cc_library(
    name = "nlopt_solver",
    srcs = select({
        "//tools:no_nlopt": [
            "nlopt_solver_common.cc",
            "no_nlopt.cc",
        ],
        "//conditions:default": [
            "nlopt_solver.cc",
            "nlopt_solver_common.cc",
        ],
    }),
    hdrs = ["nlopt_solver.h"],
    deps = select({
        "//conditions:default": [
            ":mathematical_program",
            "//math:autodiff",
            ":solver_base",
            "@nlopt",
        ],
        "//tools:no_nlopt": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

drake_cc_library(
    name = "osqp_solver",
    srcs = select({
        "//tools:no_osqp": [
            "no_osqp.cc",
            "osqp_solver_common.cc",
        ],
        "//conditions:default": [
            "osqp_solver.cc",
            "osqp_solver_common.cc",
        ],
    }),
    hdrs = ["osqp_solver.h"],
    deps = select({
        "//conditions:default": [
            ":mathematical_program",
            ":solver_base",
            "//math:eigen_sparse_triplet",
            "@osqp",
        ],
        "//tools:no_osqp": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

drake_cc_library(
    name = "scs_solver",
    srcs = select({
        "//conditions:default": [
            "scs_solver.cc",
            "scs_solver_common.cc",
        ],
        "//tools:no_scs": [
            "no_scs.cc",
            "scs_solver_common.cc",
        ],
    }),
    hdrs = ["scs_solver.h"],
    deps = select({
        "//conditions:default": [
            ":mathematical_program",
            ":solver_base",
            "//common:essential",
            "//math:eigen_sparse_triplet",
            "@scs//:scsdir",
        ],
        "//tools:no_scs": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

drake_cc_library(
    name = "sdpa_free_format",
    srcs = ["sdpa_free_format.cc"],
    hdrs = ["sdpa_free_format.h"],
    deps = [
        ":mathematical_program",
        "//common:type_safe_index",
    ],
)

drake_cc_library(
    name = "csdp_solver",
    srcs = select({
        "//conditions:default": [
            "csdp_solver.cc",
            "csdp_solver_common.cc",
            "csdp_solver_internal.cc",
        ],
        "//tools:no_csdp": [
            "no_csdp.cc",
            "csdp_solver_common.cc",
        ],
    }),
    hdrs = select({
        "//conditions:default": [
            "csdp_solver.h",
            "csdp_solver_internal.h",
        ],
        "//tools:no_csdp": [
            "csdp_solver.h",
        ],
    }),
    install_hdrs_exclude = select({
        "//conditions:default": ["csdp_solver_internal.h"],
        "//tools:no_csdp": [],
    }),
    deps = select({
        "//conditions:default": [
            ":mathematical_program",
            ":solver_base",
            ":sdpa_free_format",
            "@csdp",
        ],
        "//tools:no_csdp": [
            ":mathematical_program",
            ":solver_base",
        ],
    }),
)

# This library is empty unless Gurobi is available.
drake_cc_library(
    name = "gurobi_qp",
    srcs = select({
        "//tools:with_gurobi": [
            "qp.cc",
        ],
        "//conditions:default": [],
    }),
    hdrs = select({
        "//tools:with_gurobi": [
            "fast_qp.h",
            "gurobi_qp.h",
        ],
        "//conditions:default": [],
    }),
    deps = select({
        "//tools:with_gurobi": [
            "@eigen",
            "@gurobi//:gurobi_c",
        ],
        "//conditions:default": [],
    }),
)

drake_cc_library(
    name = "mixed_integer_optimization_util",
    srcs = ["mixed_integer_optimization_util.cc"],
    hdrs = ["mixed_integer_optimization_util.h"],
    deps = [
        ":integer_optimization_util",
        ":mathematical_program",
        "//math:gray_code",
    ],
)

# === test/ ===

drake_cc_googletest(
    name = "bilinear_product_util_test",
    deps = [
        ":bilinear_product_util",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "binding_test",
    deps = [
        ":binding",
        ":constraint",
        ":cost",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "branch_and_bound_test",
    tags = gurobi_test_tags(),
    deps = [
        ":branch_and_bound",
        ":mathematical_program_test_util",
        ":mixed_integer_optimization_util",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "evaluator_base_test",
    deps = [
        ":evaluator_base",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:is_dynamic_castable",
        "//math:gradient",
    ],
)

drake_cc_googletest(
    name = "constraint_test",
    deps = [
        ":constraint",
        "//common:symbolic",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:symbolic_test_util",
        "//math:gradient",
    ],
)

drake_cc_googletest(
    name = "minimum_value_constraint_test",
    deps = [
        ":minimum_value_constraint",
        "//solvers/test_utilities",
    ],
)

# TODO(eric.cousineau): Remove dependence on create_cost
drake_cc_googletest(
    name = "cost_test",
    deps = [
        ":cost",
        ":create_cost",
        ":generic_trivial_cost",
        "//common:symbolic",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:is_dynamic_castable",
        "//common/test_utilities:symbolic_test_util",
        "//math:gradient",
    ],
)

drake_cc_googletest(
    name = "symbolic_extraction_test",
    deps = [
        ":symbolic_extraction",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "complementary_problem_test",
    tags = ["snopt"],
    deps = [
        ":mathematical_program",
        ":solve",
    ],
)

drake_cc_googletest(
    name = "create_constraint_test",
    deps = [
        ":create_constraint",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_library(
    name = "csdp_test_examples",
    testonly = 1,
    srcs = ["test/csdp_test_examples.cc"],
    hdrs = ["test/csdp_test_examples.h"],
    deps = [
        ":mathematical_program",
        "@gtest//:without_main",
    ],
)

drake_cc_googletest(
    name = "sdpa_free_format_test",
    deps = [
        ":csdp_test_examples",
        ":sdpa_free_format",
        "//common:filesystem",
        "//common:temp_directory",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "csdp_solver_internal_test",
    deps = [
        ":csdp_solver",
        ":csdp_test_examples",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "csdp_solver_test",
    deps = [
        ":csdp_solver",
        ":csdp_test_examples",
        ":linear_program_examples",
        ":second_order_cone_program_examples",
        ":semidefinite_program_examples",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "decision_variable_test",
    deps = [
        ":mathematical_program",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "equality_constrained_qp_solver_test",
    deps = [
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:expect_throws_message",
    ],
)

drake_cc_googletest(
    name = "dreal_solver_test",
    timeout = "moderate",
    # For most of floating-point operations, Valgrind core only supports the
    # IEEE default mode (round to nearest) while dReal uses to +infinity
    # and to -infinity rounding modes intensively to maintain conservative
    # interval approximations. This causes some of the assertions to fail
    # in the test. So we disable memcheck for this test. See
    # http://valgrind.org/docs/manual/manual-core.html#manual-core.limits
    # for more information.
    tags = ["no_valgrind_tools"],
    deps = [
        ":dreal_solver",
        ":generic_trivial_constraint",
        ":generic_trivial_cost",
        ":mathematical_program",
    ],
)

drake_cc_googletest(
    name = "gurobi_solver_test",
    tags = gurobi_test_tags(),
    use_default_main = False,
    deps = [
        ":gurobi_solver",
        ":linear_program_examples",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":mixed_integer_optimization_util",
        ":quadratic_program_examples",
        ":second_order_cone_program_examples",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:expect_throws_message",
    ],
)

drake_cc_googletest(
    name = "gurobi_solver_grb_license_file_test",
    tags = gurobi_test_tags(),
    deps = [
        ":gurobi_solver",
        ":mathematical_program",
        "//common/test_utilities:expect_no_throw",
    ],
)

drake_cc_googletest(
    name = "integer_optimization_util_test",
    deps = [
        ":integer_optimization_util",
        ":mathematical_program",
        ":solve",
    ],
)

drake_cc_googletest(
    name = "ipopt_solver_test",
    deps = [
        ":linear_program_examples",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":optimization_examples",
        ":quadratic_program_examples",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "linear_complementary_problem_test",
    deps = [
        ":mathematical_program",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:expect_no_throw",
    ],
)

drake_cc_googletest(
    name = "linear_system_solver_test",
    deps = [
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":optimization_examples",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "mathematical_program_test",
    deps = [
        ":generic_trivial_constraint",
        ":generic_trivial_cost",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":solve",
        "//common:symbolic",
        "//common/test_utilities",
    ],
)

# TODO(hongkai-dai): Separate this test into a test that uses Gurobi, and a
# test that doesn't.
drake_cc_googletest(
    name = "mixed_integer_optimization_test",
    # This test uses Gurobi if present, but does not require it.
    tags = gurobi_test_tags(),
    deps = [
        ":add_solver_util",
        ":gurobi_solver",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":mosek_solver",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "moby_lcp_solver_test",
    deps = [
        ":moby_lcp_solver",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "unrevised_lemke_solver_test",
    deps = [
        ":mathematical_program",
        ":unrevised_lemke_solver",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "mosek_solver_test",
    tags = mosek_test_tags(),
    use_default_main = False,
    deps = [
        ":exponential_cone_program_examples",
        ":linear_program_examples",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":mixed_integer_optimization_util",
        ":quadratic_program_examples",
        ":second_order_cone_program_examples",
        ":semidefinite_program_examples",
        "//common:filesystem",
        "//common:temp_directory",
    ],
)

drake_cc_googletest(
    name = "mosek_solver_moseklm_license_file_test",
    tags = mosek_test_tags(),
    deps = [
        ":mathematical_program",
        ":mosek_solver",
        "//common/test_utilities:expect_no_throw",
    ],
)

drake_cc_googletest(
    name = "nlopt_solver_test",
    deps = [
        ":linear_program_examples",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":optimization_examples",
        ":quadratic_program_examples",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "non_convex_optimization_util_test",
    # This test is quite long, so split it into 4 processes for better latency.
    shard_count = 4,
    tags = mosek_test_tags(),
    deps = [
        ":decision_variable",
        ":non_convex_optimization_util",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "nonlinear_program_test",
    deps = [
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":optimization_examples",
        "//common/test_utilities",
    ],
)

drake_cc_googletest(
    name = "mixed_integer_rotation_constraint_test",
    timeout = "long",
    # This test is quite long, so split it into 4 processes for better latency.
    shard_count = 4,
    tags = gurobi_test_tags() + mosek_test_tags() + [
        # Excluding asan and memcheck because it is unreasonably slow
        # (> 30 minutes).
        "no_asan",
        "no_memcheck",
        # Excluding tsan because an assertion fails in LLVM code. Issue #6179.
        "no_tsan",
    ],
    use_default_main = False,
    deps = [
        ":gurobi_solver",
        ":mathematical_program",
        ":mixed_integer_rotation_constraint",
        ":mosek_solver",
        ":rotation_constraint",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//math:geometric_transform",
    ],
)

drake_cc_googletest(
    name = "mixed_integer_rotation_constraint_corner_test",
    timeout = "long",
    # This test is quite long, so split it into 4 processes for better latency.
    shard_count = 4,
    tags = gurobi_test_tags() + mosek_test_tags() + [
        # Excluding asan because it is unreasonably slow (> 30 minutes).
        "no_asan",
        # Excluding tsan because an assertion fails in LLVM code. Issue #6179.
        "no_tsan",
    ],
    use_default_main = False,
    deps = [
        ":mathematical_program",
        ":mixed_integer_rotation_constraint",
        ":mosek_solver",
        ":rotation_constraint",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "rotation_constraint_test",
    timeout = "long",
    # This test is quite long, so split it into 4 processes for better latency.
    shard_count = 4,
    tags = gurobi_test_tags() + mosek_test_tags() + [
        # Excluding asan because it is unreasonably slow (> 30 minutes).
        "no_asan",
        # Excluding tsan because an assertion fails in LLVM code. Issue #6179.
        "no_tsan",
    ],
    use_default_main = False,
    deps = [
        ":gurobi_solver",
        ":mathematical_program",
        ":rotation_constraint",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//math:geometric_transform",
    ],
)

drake_cc_googletest(
    name = "osqp_solver_test",
    deps = [
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":osqp_solver",
        ":quadratic_program_examples",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_binary(
    name = "plot_feasible_rotation_matrices",
    testonly = 1,
    srcs = ["test/plot_feasible_rotation_matrices.cc"],
    deps = [
        ":mathematical_program",
        ":mixed_integer_rotation_constraint",
        ":rotation_constraint",
        ":solve",
        "//common/proto:call_python",
    ],
)

drake_cc_googletest(
    name = "program_attribute_test",
    deps = [
        ":program_attribute",
    ],
)

drake_cc_googletest(
    name = "mixed_integer_rotation_constraint_limit_test",
    timeout = "long",
    tags = gurobi_test_tags() + [
        # Times out with Valgrind
        "no_memcheck",
        # Excluding tsan because an assertion fails in LLVM code. Issue #6179.
        "no_tsan",
    ],
    deps = [
        ":gurobi_solver",
        ":mathematical_program",
        ":mixed_integer_rotation_constraint",
        ":rotation_constraint",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "scs_solver_test",
    deps = [
        ":exponential_cone_program_examples",
        ":linear_program_examples",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":quadratic_program_examples",
        ":second_order_cone_program_examples",
        ":semidefinite_program_examples",
    ],
)

drake_cc_googletest(
    name = "snopt_solver_test",
    tags = [
        # ThreadSanitizer: lock-order-inversion (potential deadlock) with
        # snopt_fortran (#11657).
        "no_tsan",
        "snopt",
    ],
    deps = [
        ":linear_program_examples",
        ":mathematical_program",
        ":mathematical_program_test_util",
        ":optimization_examples",
        ":quadratic_program_examples",
        "//common:filesystem",
        "//common:temp_directory",
        "//common/test_utilities:eigen_matrix_compare",
        "//math:geometric_transform",
    ],
)

drake_cc_googletest(
    name = "solver_base_test",
    deps = [
        ":mathematical_program",
        ":solver_base",
        "//common/test_utilities:expect_throws_message",
    ],
)

drake_cc_googletest(
    name = "solver_id_test",
    deps = [
        ":solver_id",
    ],
)

drake_cc_googletest(
    name = "solver_type_converter_test",
    deps = [
        ":mathematical_program",
        ":solver_type_converter",
    ],
)

drake_cc_googletest(
    name = "sos_constraint_test",
    tags = mosek_test_tags(),
    deps = [
        ":mathematical_program",
        ":solve",
        ":sos_basis_generator",
        "//common/test_utilities",
    ],
)

drake_cc_googletest(
    name = "sos_basis_generator_test",
    deps = [
        ":mathematical_program",
        ":sos_basis_generator",
    ],
)

drake_cc_googletest(
    name = "integer_inequality_solver_test",
    deps = [
        ":integer_inequality_solver",
    ],
)

drake_cc_googletest(
    name = "system_identification_test",
    # Test timeout increased to not timeout in debug and when run with
    # Valgrind.
    timeout = "moderate",
    deps = [
        ":system_identification",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_binary(
    name = "plot_rotation_mccormick_envelope",
    testonly = 1,
    srcs = ["test/plot_rotation_mccormick_envelope.cc"],
    deps = [
        ":rotation_constraint_visualization",
    ],
)

drake_cc_googletest(
    name = "mixed_integer_optimization_util_test",
    tags = gurobi_test_tags(gurobi_required = False),
    deps = [
        ":gurobi_solver",
        ":mixed_integer_optimization_util",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "mixed_integer_rotation_constraint_internal_test",
    tags = mosek_test_tags() + gurobi_test_tags() + ["no_tsan"],
    deps = [
        ":mathematical_program",
        ":mixed_integer_rotation_constraint",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//math:geometric_transform",
    ],
)

drake_cc_googletest(
    name = "diagonally_dominant_matrix_test",
    deps = [
        ":mathematical_program",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "scaled_diagonally_dominant_matrix_test",
    tags = gurobi_test_tags() + mosek_test_tags(),
    deps = [
        ":mathematical_program",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "mathematical_program_result_test",
    deps = [
        ":cost",
        ":mathematical_program_result",
        ":osqp_solver",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:expect_throws_message",
    ],
)

drake_cc_googletest(
    name = "choose_best_solver_test",
    deps = [
        ":choose_best_solver",
        "//common/test_utilities:expect_throws_message",
    ],
)

drake_cc_googletest(
    name = "solve_test",
    deps = [
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "solver_options_test",
    deps = [
        ":solver_options",
        "//common/test_utilities:expect_no_throw",
        "//common/test_utilities:expect_throws_message",
    ],
)

# The extra_srcs are required here because add_lint_tests() doesn't understand
# how to extract labels from select() functions yet.
add_lint_tests(cpplint_extra_srcs = [
    "csdp_solver.h",
    "csdp_solver.cc",
    "csdp_solver_common.cc",
    "csdp_solver_internal.h",
    "csdp_solver_internal.cc",
    "dreal_solver.cc",
    "dreal_solver.h",
    "dreal_solver_common.cc",
    "fast_qp.h",
    "gurobi_qp.h",
    "gurobi_solver.cc",
    "gurobi_solver.h",
    "gurobi_solver_common.cc",
    "ipopt_solver.cc",
    "ipopt_solver.h",
    "ipopt_solver_common.cc",
    "mosek_solver.cc",
    "mosek_solver.h",
    "mosek_solver_common.cc",
    "nlopt_solver.cc",
    "nlopt_solver.h",
    "nlopt_solver_common.cc",
    "no_csdp.cc",
    "no_dreal.cc",
    "no_gurobi.cc",
    "no_ipopt.cc",
    "no_mosek.cc",
    "no_nlopt.cc",
    "no_osqp.cc",
    "no_scs.cc",
    "no_snopt.cc",
    "osqp_solver.cc",
    "osqp_solver_common.cc",
    "qp.cc",
    "scs_solver.cc",
    "scs_solver_common.cc",
    "snopt_solver.cc",
    "snopt_solver.h",
    "snopt_solver_common.cc",
])