Revision history [back]

The list of available parameters for Gurobi 7.0 is available in this link. (true that the Sage should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. Apparently Gurobi already tries to use, by default, all available processor (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for the Threads one just has to do for example:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads", 4)

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that the Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. Apparently Gurobi already tries to use, by default, all available processor (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for the Threads one just has to do for example:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads", 4)

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. Apparently Gurobi already tries to use, by default, all available processor ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for the Threads one just has to do for example:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads", 4)

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. Apparently Gurobi already tries to use, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for the Threads one just has to do for example:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads", 4)

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. Apparently Gurobi already tries to use, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for the Threads one just has to do for example:example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads", 4)

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. Apparently Gurobi already tries to use, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)
4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. Apparently Gurobi already tries to use, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms, and whose maximum value is the number of processors. algorithms. Apparently Gurobi already tries to use, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms. Apparently Gurobi already tries to use, uses, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms. Apparently Gurobi already uses, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_type in gurobi_backend.pyx. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms. Apparently Gurobi already uses, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All the allowed solver parameters for Gurobi are those listed in the dictionary pareters_typeparameters_type in gurobi_backend.pyx. Be careful because since keywords may be added or removed from version to version of Gurobi, this is not necessarily up-to-date, and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms. Apparently Gurobi already uses, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All the allowed solver parameters for Gurobi are those listed in the dictionary parameters_type in gurobi_backend.pyx. Be careful because since keywords may be added or removed from version to version of Gurobi, this the dictionary is not necessarily up-to-date, up-to-date and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms. Apparently Gurobi already uses, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

All In Sage, the allowed solver parameters for the Gurobi backend are those listed in the dictionary parameters_type in gurobi_backend.pyx. Be careful because since keywords may be added or removed from version to version of Gurobi, the dictionary is not necessarily up-to-date and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms. Apparently Gurobi already uses, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

In Sage, the allowed solver parameters for the Gurobi backend are those listed in the dictionary parameters_type in gurobi_backend.pyx. Be careful because since keywords may be added or removed from version to version of Gurobi, the dictionary is not necessarily up-to-date and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)

The list of available parameters for Gurobi 7.0 is available in this link. (true that Sage help should better point to the general doc, because the previous link changes among versions..)

The parameter that you are interested in seems to be Threads, which controls the number of threads to apply to parallel algorithms. Apparently Gurobi already uses, by default, all available ones (see in the Threads description, or here). In any case, there are also other parameters to control parallelism.

So for example we can do:

sage: p = MixedIntegerLinearProgram(solver="Gurobi")
sage: p.solver_parameter("Threads")     # query the actual value
0
sage: p.solver_parameter("Threads", 4)    # set a new value
sage: p.solver_parameter("Threads")    # query the new value
4

In Sage, the allowed solver parameters for the Gurobi backend are listed in the dictionary parameters_type in gurobi_backend.pyx. Be careful because since keywords may be added or removed from version to version of Gurobi, the dictionary is not necessarily up-to-date and may brake, but as Nathan explains in that file, it is a matter of changing the source code and recompiling sage! (make start)