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_lite",
        ":mathematical_program_private",
        ":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_result",
        ":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_private",
        ":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: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",
    ],
)

# TODO(jwnimmer-tri) We'd like to have this simply be `cc_library(name =
# "mathematical_program", ...)` without "_private" suffix and having
# `visibility = ["//visibility:public"]`, but for now that name is taken by a
# deprecated alias.  Once that alias is gone, we should rename this target.
drake_cc_library(
    name = "mathematical_program_private",
    srcs = [
        "mathematical_program.cc",
    ],
    hdrs = [
        "mathematical_program.h",
    ],
    visibility = ["//visibility:private"],
    deps = [
        ":binding",
        ":create_constraint",
        ":create_cost",
        ":decision_variable",
        ":function",
        ":indeterminate",
        ":mathematical_program_result",
        ":program_attribute",
        ":solution_result",
        ":solver_id",
        ":solver_options",
        ":solver_result",
        ":sos_basis_generator",
        ":symbolic_extraction",
        "//common:autodiff",
        "//common:essential",
        "//common:polynomial",
        "//common:symbolic",
    ],
)

# The target "@drake//solvers:mathematical_program_lite" is (for now) the best
# way to access the `drake/solvers/mathematical_program.h` header and its
# methods.  In the future, this target will become deprecated in lieu of
# `@drake//solvers:mathematical_program`, but for now that label is deprecated
# because it brings in more than just `class MathematicalProgram`.
drake_cc_library(
    name = "mathematical_program_lite",
    deps = [
        ":mathematical_program_private",
        ":solver_interface",
    ],
)

# TODO(jwnimmer-tri) Remove this target on 2019-09-01.
drake_cc_library(
    name = "mathematical_program",
    deprecation = " ".join([
        "The label @drake//solvers:mathematical_program is vestigial sugar",
        "for depending on both class MathematicalProgram as well as all",
        "implementations of SolverInterface. Users should respell their deps",
        "as @drake//solvers:mathematical_program_lite plus any other solvers",
        "they need (or @drake//solvers:solve, etc.).  This label will stop",
        "depending on SolverInterface and specific solvers on 2019-09-01.",
    ]),
    tags = [
        # Avoid 'build //...' yelling at us.
        "manual",
    ],
    deps = [
        ":choose_best_solver",
        ":mathematical_program_private",
    ],
)

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

drake_cc_library(
    name = "solver_interface",
    srcs = [
        "solver_interface.cc",
    ],
    hdrs = [
        "solver_interface.h",
    ],
    deps = [
        ":mathematical_program_private",
        ":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_private",
        ":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_private",
        ":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_private",
        ":solve",
        "//common:autodiff",
        "//common:essential",
        "//common:polynomial",
    ],
)

drake_cc_library(
    name = "rotation_constraint",
    srcs = [
        "rotation_constraint.cc",
    ],
    hdrs = [
        "rotation_constraint.h",
    ],
    deps = [
        ":mathematical_program_private",
        "//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_private",
        ":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_private",
        ":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_private",
        ":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_private",
        ":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_result",
    hdrs = ["solver_result.h"],
    deprecation = "This label is deprecated and will be removed from Drake on 2019-09-01.",  # noqa
    # Exclude the target from `bazel build //...`, so that we don't get
    # deprecation warnings from a normal build.
    tags = ["manual"],
    deps = [
        "//common:essential",
    ],
)

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

drake_cc_library(
    name = "solve",
    srcs = ["solve.cc"],
    hdrs = ["solve.h"],
    deps = [
        ":choose_best_solver",
        ":mathematical_program_private",
        "//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_private",
        ":solver_base",
        "//common:essential",
    ],
)

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

drake_cc_library(
    name = "unrevised_lemke_solver",
    srcs = ["unrevised_lemke_solver.cc"],
    hdrs = ["unrevised_lemke_solver.h"],
    deps = [
        ":mathematical_program_private",
        ":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_private",
        ":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_private",
            ":solver_base",
            "//common:essential",
            "@dreal",
        ],
        "//tools:no_dreal": [
            ":mathematical_program_private",
            ":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_private",
            ":solver_base",
            "//math:eigen_sparse_triplet",
            "//common:scoped_singleton",
            "@gurobi//:gurobi_c",
            "@fmt",
        ],
        "//conditions:default": [
            ":mathematical_program_private",
            ":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_private",
            ":mathematical_program_result",
            ":solver_base",
            "//common:scoped_singleton",
            "@mosek",
        ],
        "//conditions:default": [
            ":mathematical_program_private",
            ":mathematical_program_result",
            ":solver_base",
        ],
    }),
)

# If --config snopt (or one of --config snopt_{fortran,f2c}) 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({
        # The `--config snopt` ("Use the default SNOPT flavor") is a synonym
        # for `--config snopt_fortran` ("Use the Fortran SNOPT flavor").
        "//tools:with_snopt": [
            "snopt_solver.cc",
            "snopt_solver_common.cc",
        ],
        # This is always the Fortran flavor.
        "//tools:with_snopt_fortran": [
            "snopt_solver.cc",
            "snopt_solver_common.cc",
        ],
        # This is always the f2c flavor.
        "//tools:with_snopt_f2c": [
            "snopt_solver_f2c.cc",
            "snopt_solver_common.cc",
        ],
        # This is when SNOPT is disabled / unavailable.
        "//conditions:default": [
            "no_snopt.cc",
            "snopt_solver_common.cc",
        ],
    }),
    hdrs = ["snopt_solver.h"],
    deps = select({
        # This is Drake's default flavor (Fortran).
        "//tools:with_snopt": [
            ":mathematical_program_private",
            ":solver_base",
            "//math:autodiff",
            "@snopt//:snopt_cwrap",
        ],
        # This is always the Fortran flavor.
        "//tools:with_snopt_fortran": [
            ":mathematical_program_private",
            ":solver_base",
            "//math:autodiff",
            "@snopt//:snopt_cwrap",
        ],
        # This is always the f2c flavor.
        "//tools:with_snopt_f2c": [
            ":mathematical_program_private",
            ":solver_base",
            "//math:autodiff",
            "@snopt//:snopt_c",
        ],
        # This is when SNOPT is disabled / unavailable.
        "//conditions:default": [
            ":mathematical_program_private",
            ":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_private",
            ":solver_base",
            "//common:unused",
            "//math:autodiff",
        ],
        "//tools:no_ipopt": [
            ":mathematical_program_private",
            ":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_private",
            "//math:autodiff",
            ":solver_base",
            "@nlopt",
        ],
        "//tools:no_nlopt": [
            ":mathematical_program_private",
            ":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_private",
            ":solver_base",
            "//math:eigen_sparse_triplet",
            "@osqp",
        ],
        "//tools:no_osqp": [
            ":mathematical_program_private",
            ":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_private",
            ":solver_base",
            "//common:essential",
            "//math:eigen_sparse_triplet",
            "@scs//:scsdir",
        ],
        "//tools:no_scs": [
            ":mathematical_program_private",
            ":solver_base",
        ],
    }),
)

drake_cc_library(
    name = "sdpa_free_format",
    srcs = ["sdpa_free_format.cc"],
    hdrs = ["sdpa_free_format.h"],
    deps = [
        ":mathematical_program_lite",
        "//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_private",
            ":solver_base",
            ":sdpa_free_format",
            "@csdp",
        ],
        "//tools:no_csdp": [
            ":mathematical_program_private",
            ":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_private",
        "//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_private",
        ":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:temp_directory",
        "//common/test_utilities:eigen_matrix_compare",
        "@spruce",
    ],
)

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_private",
        "//common/test_utilities:symbolic_test_util",
    ],
)

drake_cc_googletest(
    name = "equality_constrained_qp_solver_test",
    deps = [
        ":mathematical_program_private",
        ":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_private",
    ],
)

drake_cc_googletest(
    name = "gurobi_solver_test",
    tags = gurobi_test_tags(),
    use_default_main = False,
    deps = [
        ":gurobi_solver",
        ":linear_program_examples",
        ":mathematical_program_private",
        ":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_private",
    ],
)

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

drake_cc_googletest(
    name = "ipopt_solver_test",
    deps = [
        ":linear_program_examples",
        ":mathematical_program_private",
        ":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_private",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
    ],
)

drake_cc_googletest(
    name = "linear_system_solver_test",
    deps = [
        ":mathematical_program_private",
        ":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_private",
        ":mathematical_program_test_util",
        ":solve",
        "//common:symbolic",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:expect_throws_message",
        "//common/test_utilities:is_dynamic_castable",
        "//common/test_utilities:symbolic_test_util",
    ],
)

# 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_private",
        ":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_private",
        ":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_private",
        ":mathematical_program_test_util",
        ":mixed_integer_optimization_util",
        ":quadratic_program_examples",
        ":second_order_cone_program_examples",
        ":semidefinite_program_examples",
        "//common:temp_directory",
        "@spruce",
    ],
)

drake_cc_googletest(
    name = "mosek_solver_moseklm_license_file_test",
    tags = mosek_test_tags(),
    deps = [
        ":mathematical_program_private",
        ":mosek_solver",
    ],
)

drake_cc_googletest(
    name = "nlopt_solver_test",
    deps = [
        ":linear_program_examples",
        ":mathematical_program_private",
        ":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_private",
        ":mathematical_program_test_util",
        ":optimization_examples",
        "//common/test_utilities:eigen_matrix_compare",
        "//common/test_utilities:is_dynamic_castable",
    ],
)

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_private",
        ":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_private",
        ":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_private",
        ":rotation_constraint",
        ":solve",
        "//common/test_utilities:eigen_matrix_compare",
        "//math:geometric_transform",
    ],
)

drake_cc_googletest(
    name = "osqp_solver_test",
    deps = [
        ":mathematical_program_private",
        ":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_private",
        ":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_private",
        ":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_private",
        ":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_private",
        ":mathematical_program_test_util",
        ":optimization_examples",
        ":quadratic_program_examples",
        "//common:temp_directory",
        "//common/test_utilities:eigen_matrix_compare",
        "//math:geometric_transform",
        "@spruce",
    ],
)

drake_cc_googletest(
    name = "solver_base_test",
    deps = [
        ":mathematical_program_private",
        ":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_private",
        ":solver_type_converter",
    ],
)

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

drake_cc_googletest(
    name = "sos_basis_generator_test",
    deps = [
        ":mathematical_program_private",
        ":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_private",
        ":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_private",
        ":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_private",
        ":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_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",
    "snopt_solver_f2c.cc",
])