1 | initial version |

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`

)

2 | No.2 Revision |

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`

)

3 | No.3 Revision |

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`

)

4 | No.4 Revision |

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)
```

`make start`

)

5 | No.5 Revision |

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)
```

`make start`

)

6 | No.6 Revision |

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

`make start`

)

7 | No.7 Revision |

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
```

`make start`

)

8 | No.8 Revision |

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
```

`make start`

)

9 | No.9 Revision |

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
```

`make start`

)

10 | No.10 Revision |

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`

)

11 | No.11 Revision |

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~~parameters_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`

)

12 | No.12 Revision |

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`

)

13 | No.13 Revision |

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`

)

14 | No.14 Revision |

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`

)

15 | No.15 Revision |

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`

)

Copyright Sage, 2010. Some rights reserved under creative commons license. Content on this site is licensed under a Creative Commons Attribution Share Alike 3.0 license.