Module docplex.cp.model¶
This module contains principally the class CpoModel
that handles all the elements that compose a CPO model:
 the variables of the domain (integer variables, interval variables, sequence variables and state functions),
 the constraints of the model,
 optional objective value(s),
 optional search phases,
 optional starting point (available for CPO solver release greater or equal to 12.7.0).
The model expressions, constraints, objective and search phases can be added using method add()
.
Variables that appear in the expressions are automatically added to the model.
A starting point can be added to the model using method set_starting_point()
The different model expressions and elements are created using services provided by modules:
docplex.cp.expression
for the simple expression elements,docplex.cp.modeler
for complex expressions and constraints using the specialized CP Optimizer functions.
The solving of the model is handled by an object of class CpoSolver
that takes
this model as parameter.
However, most important solving functions are callable directly from this model to avoid explicit
creation of the CpoSolver object:
solve()
solves the model and returns an object of classCpoSolveResult
.start_search()
creates a solver that can iterate over multiple solutions of the model.refine_conflict()
identifies a minimal conflict for the infeasibility and return it as an object of classCpoRefineConflictResult
.propagate()
invokes the propagation on the current model and returns a partial solution in an object of classCpoSolveResult
.
All these methods are taking a variable number of optional parameters that allow to modify the solving context.
The list of arguments is not limited. Each named argument is used to replace the leaf attribute that has
the same name in the global context structure initialized in the module docplex.cp.config
and its
customizations.
The most important of these parameters are:
context sets a complete customized context to be used instead of the default one defined in the module
docplex.cp.config
,params overwrites the solving parameters (object of class
CpoParameters
) that are defined in the context object,agent forces the selection of a particular solving agent,
trace_cpo activates the printing of the model in CPO format before its solve,
any CP Optimizer solving parameter, as defined in module
docplex.cp.parameters
, such as:
 TimeLimit indicates a limit in seconds in the time spent in the solve, or ConflictRefinerTimeLimit that does the same for conflict refiner,
 LogVerbosity, with values in [‘Quiet’, ‘Terse’, ‘Normal’, ‘Verbose’],
 Workers specifies the number of threads assigned to solve the model (default value is the number of cores),
 SearchType, with value in [‘DepthFirst’, ‘Restart’, ‘MultiPoint’, ‘IterativeDiving’, ‘Neighborhood’, ‘Auto’], to select a particular solving algorithm,
 RandomSeed changes the seed of the random generator,
 and so on.
Detailed description¶

class
docplex.cp.model.
CpoModel
(name=None, sfile=None, version=None)[source]¶ Bases:
object
This class is the Python container of a CPO model.
Constructor
Parameters:  name – (Optional) Model name (source file name).
 sfile – (Optional) Source file.
 version – (Optional) Format version

add
(*expr)[source]¶ Adds one or several expressions to the model.
This method adds one or more CPO expression to the model. A CPO expression is an object of class
CpoExpr
or derived, obtained by: calling one of the factory method available in module
docplex.cp.expression
,  calling one of the modeling function available in module
docplex.cp.modeler
,  using an overloaded operator with at least one argument that is a
CpoExpr
or derived.
The argument expr can be:
 a constraint,
 a boolean expression, possibly constant,
 an objective,
 a search phase,
 a variable (but variables that appear in expressions are automatically added to the model),
 an iterable of expressions to add.
The order of the expressions that are added to the model is preserved when it is submitted for solving.
Parameters: expr – CPO expressions (constraint, boolean, objective, etc) to add to the model, or iterable of expressions to add to the model.  calling one of the factory method available in module

add_blackbox_function
(bbf)[source]¶ Add a new blackbox function descriptor to this model.
Calling this function is mandatory before importing a CPO model that contains references to a blackbox function, if the context attribute context.parser.auto_blackbox is set to False (default).
If the context attribute context.parser.auto_blackbox is set to True, then an empty blackbox function descriptor is automatically generated for every unknown function in the model. As there is no implementation, the model can not be solved.
Parameters: bbf – Blackbox function descriptor, object of class CpoBlackboxFunction

add_constraint
(expr)[source]¶ Adds a constraint to the model.
This method has been added for compatibility with docplex.mp. It is equivalent to method
add()
Parameters: expr – Constraint expression to add to the model,

add_kpi
(expr, name=None)[source]¶ Add a Key Performance Indicator to the model.
A Key Performance Indicators (KPI) is an expression whose value is considered as representative of the model solution and its quality.
For example, in a scheduling problem one may wish to minimize the makespan (date at which all tasks are completed), but other values may be of interest, like the average job completion time, or the maximum number of tasks executing in parallel over the horizon. One can identify such expressions in the model by marking them as KPIs.
For CPO solver version lower than 12.9, KPI expressions are limited to:
 an integer variable,
 a Python lambda expression that computes the value of the KPI from the solve result given as parameter.
Example of lambda expression used as KPI:
mdl = CpoModel() a = integer_var(0, 3) b = integer_var(0, 3) mdl.add(a < b) mdl.add_kpi(lambda res: (res[a] + res[b]) / 2, "Average")
For CPO solver version greater or equal to 12.9, KPI expressions can be any model expression. KPI values are automatically displayed in the log, can be queried after the solve or for each solution, and are exported to a CPO file when the model is exported.
If the model is solved in a cloud context, the KPIs are associated to the objective value in the solve details that are sent periodically to the client.
Parameters:  expr – Model variable to be used as KPI(s).
 name (optional) – Name used to publish this KPI. If absent the expression name is used. If the expression has no name, an exception is raised.

add_parameters
(**kwargs)[source]¶ Add parameters to this model.
This method adds parameters to the
CpoParameters
object currently associated to the model. If there is no such parameters object yet, a newCpoParameters
is created.Parameters: **kwargs (Optional) – List of parameters assignments.

add_search_phase
(phase)[source]¶ Add a search phase to the list of search phases
This method is deprecated since release 2.3. Use
set_search_phases()
oradd()
instead.Parameters: phase – Phase to add to the list

add_solver_callback
(cback)[source]¶ Add a CPO solver callback.
A solver callback is an object extending the class
CpoCallback
which provides multiple functions that are called by the solver engine to notify about the different solving steps.Parameters: cback – Solver callback, object extending CpoCallback

add_solver_listener
(lstnr)[source]¶ Add a solver listener.
A solver listener is an object extending the class
CpoSolverListener
which provides multiple functions that are called to notify about the different solving steps.Parameters: lstnr – Solver listener

check_equivalence
(other)[source]¶ Checks that this model is equivalent to another.
Variables and expressions are compared, but not names that may differ because of automatic naming.
Parameters: other – Other model to compare with. Raises: CpoException
– if models are not equivalent

clone
()[source]¶ Create a copy of this model.
Result copy duplicates only the toplevel attributes of the model, the list of expressions, and the parameters. It does not create a deep copy of the expressions, which means that a variable referenced by the expressions of this model is physically the same in the copy.
To completely duplicate the model and all its elements, use the standard function copy.deepcopy(…).

create_empty_solution
()[source]¶ Create an empty model solution that can be filled to be used as a starting point.
New in version 2.9
Returns: New empty model solution, object of class CpoModelSolution

create_solver
(**kwargs)[source]¶ Create a new solver instance attached to this model
All necessary solving parameters are taken from the solving context that is constructed from the following list of sources, each one overwriting the previous:
Parameters:  context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module
config
.  params (Optional) – Solving parameters (object of class
CpoParameters
) that overwrite those in the solving context.  (param) (Optional) – Any individual solving parameter as defined in class
CpoParameters
(for example TimeLimit, Workers, SearchType, etc).  (others) (Optional) – Any leaf attribute with the same name in the solving context (for example agent, trace_log, trace_cpo, etc).
Returns: New solver properly initialized.
 context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module

equals
(other)[source]¶ Checks if this model is equal to another.
Parameters: other – Other model to compare with. Returns: True if models are identical, False otherwise.

explain_failure
(ltags=None, **kwargs)[source]¶ This method allows to explain solve failures.
If called with no arguments, this method invokes a solve of the model with appropriate parameters that enable, in the log, the print of a number tag for each solve failure.
If called with a list of failure tag to explain, the solver is invoked again in a way that it explains, in the log, the reason for the failure of the required failure tags.
This method sets the following solve parameters before calling the solver:
LogSearchTags
= ‘On’Workers
= 1LogPeriod
= 1SearchType
= ‘DepthFirst’
Parameters:  ltags (Optional) – List of tag ids to explain. If empty or None, the solver is just invoked with appropriate solve parameters to make failure tags displayed in the log.
 (others) (Optional) – Any other solve attribute as it can be passed to method
solve()
.
Returns: Solve result, object of class
CpoSolveResult
.Raises: CpoNotSupportedException
– if method not available in the solver agent.CpoException
– (or derived) if error.

export_as_cpo
(out=None, **kwargs)[source]¶ Deprecated form of method
export_model()
.

export_model
(out=None, **kwargs)[source]¶ Exports/prints the model in the standard CPO file format.
Except for the argument out, all other arguments are the same than those available in the solve() method., but However, only thoss that impact the CPO file format are useful, in particular, the solving parameters. For example:
mdl.export_model(Workers=1, TimeLimit=100)
Note that calling this method disables automatically all the settings that are set in the default configuration to change the format of the model:
 context.model.length_for_alias that rename variables if name is too long,
 context.model.name_all_constraints that force a name for each constraint.
These options are however possible if explicitly given as parameter of this method, as in:
mdl.export_model(length_for_alias=10)
Parameters:  out (Optional) – Target output, stream or file name. Default is sys.stdout.
 context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module
config
.  params (Optional) – Solving parameters (object of class
CpoParameters
) that overwrite those in the solving context.  add_source_location (Optional) – Add source location into generated text
 length_for_alias (Optional) – Minimum name length to use shorter alias instead
 (others) (Optional) – Any leaf attribute with the same name in the solving context

get_all_expressions
()[source]¶ Gets the list of all model expressions
Returns: List of model expressions including there location (if any). Each expression is a tuple (expr, loc) where loc is a tuple (source_file, line), or None if not set.

get_all_variables
()[source]¶ Gets the list of all model variables.
This method goes across all model expressions to identify all variables that are pointed by them. Calling this method on a big model may be slow.
Returns: List of model variables.

get_blackbox_function
(name)[source]¶ Gets a particular blackbox function from its name.
Parameters: name – Name of the blackbox function to search for Returns: Blackbox function descriptor, None if not found

get_blackbox_functions
()[source]¶ Gets the list of all blackbox functions registered in this model.
Returns: List of all blackbox functions occurring in this model, objects of class CpoBlackboxFunction

get_cpo_string
(**kwargs)[source]¶ Compiles the model in CPO file format into a string.
Note that calling this method disables automatically all the settings that are set in the default configuration to change the format of the model:
 context.model.length_for_alias that rename variables if name is too long,
 context.model.name_all_constraints that force a name for each constraint.
These options are however possible if explicitly given as parameter of this method, as in:
mstr = mdl.get_cpo_string(length_for_alias=10)
Parameters:  context – Global solving context. If not given, context is the default context that is set in config.py.
 params – Solving parameters (CpoParameters) that overwrites those in solving context
 add_source_location – Add source location into generated text
 length_for_alias – Minimum name length to use shorter alias instead
 (others) – All other context parameters that can be changed
Returns: String containing the model.

get_format_version
()[source]¶ Gets the version of the CPO format.
This information is set only when parsing an existing CPO model that contains explicitly a version of the format. It is usually not set when creating a new model. It can be set explicitly using
set_format_version()
if a specific CPO format is expected.Returns: String containing the version of the CPO format. None for default.

get_kpis
()[source]¶ Returns the dictionary of this model KPIs.
Returns: Ordered dictionary of KPIs. Key is publish name, value is kpi as a tuple (expr, loc) where loc is a tuple (source_file, line). Keys are sorted in the order the KPIs have been defined.

get_modeling_duration
()[source]¶ Get the time spent in modeling.
The time is computes as difference between the last time an expression has been added and the model object creation time.
Returns: Modeling duration in seconds

get_name
()[source]¶ Gets the name of the model.
If the name is not explicitly defined, the name is the source file name without its extension. If source file name is also undefined, name is None.
Returns: Name of the model, None if undefined.

get_named_expressions_dict
()[source]¶ Gets a dictionary of all named expressions.
This method goes across all model expressions to identify all named expressions. Calling this method on a big model may be slow.
Returns: Dictionary of all named expressions. Key is expression name, value is expression.

get_objective
()[source]¶ Gets the objective expression (maximization or minimization).
Returns: Objective expression, None if satisfaction problem.

get_objective_expression
()[source]¶ Gets the objective expression (maximization or minimization).
Returns: Objective expression, None if satisfaction problem.

get_optimization_expression
()[source]¶ Gets the optimization expression (maximization or minimization).
DEPRECATED. Use
get_objective()
instead.Returns: Optimization expression, None if satisfaction problem.

get_parameters
()[source]¶ Get the solving parameters associated to this model.
Returns: Solving parameters, object of class CpoParameters
, or None if not defined.

get_source_file
()[source]¶ Gets the name of the source file from which model has been created.
Returns: Python source file name. None if undefined.

get_starting_point
()[source]¶ Get the model starting point
Returns: Model starting point, None if none

get_statistics
()[source]¶ Get statistics on the model
This methods compute statistics on the model.
Returns: Model statistics, object of class class CpoModelStatistics
.

import_model
(file)[source]¶ Import a model from a file containing a model expressed in CPO, FZN or LP format.
FZN and LP formats are supported with restrictions to integer variables. The full list of supported FZN predicates is given in the documentation of module
fzn_parser
.Source files can also be provided compressed, in zip or gzip format.
Parameters: file – Name of the input file, with extension “.cpo”, “.fzn” or “.lp”, optionally followed by “.gz” or “.zip”

import_model_string
(cpostr, **kwargs)[source]¶ Import in this model a model contained in a string in CPO format.
Parameters:  cpostr – Model in CPO format given as a string.
 **kwargs – (Optional) context changes

is_maximization
()[source]¶ Check if this model represents a maximization problem.
Returns: True if this model represents a maximization problem.

is_minimization
()[source]¶ Check if this model represents a minimization problem.
Returns: True if this model represents a minimization problem.

is_satisfaction
()[source]¶ Check if this model represents a satisfaction problem.
Returns: True if this model represents a satisfaction problem.

maximize
(expr)[source]¶ Add an objective expression to maximize.
DEPRECATED: use add(maximize()) instead.
Parameters: expr – Expression to maximize. Returns: Maximization expression that has been added

merge_with_parameters
(params)[source]¶ Merge parameters of this model with external parameters.
The model parameters (if any) are overwritten by the given parameters. If parameters are defined at model level, they are cloned, and the parameters given as argument are added to it and then returned. If no parameters are defined, the parameters given as argument are returned as they are.
Returns: Merged solving parameters, object of class CpoParameters
.

minimize
(expr)[source]¶ Add an objective expression to minimize.
DEPRECATED: use add(minimize()) instead.
Parameters: expr – Expression to minimize. Returns: Minimization expression that has been added

print_information
(out=None)[source]¶ Prints model information.
DEPRECATED. Use
write_information()
instead.Parameters: out – Output stream or file name, default is sys.stdout.

propagate
(cnstr=None, **kwargs)[source]¶ This method invokes the propagation on the current model.
Constraint propagation is the process of communicating the domain reduction of a decision variable to all of the constraints that are stated over this variable. This process can result in more domain reductions. These domain reductions, in turn, are communicated to the appropriate constraints. This process continues until no more variable domains can be reduced or when a domain becomes empty and a failure occurs. An empty domain during the initial constraint propagation means that the model has no solution.
The result is a object of class
CpoSolveResult
, the same than the one returned by the methodsolve()
. However, variable domains may not be completely defined.This method creates a new
CpoSolver
with given arguments, and then call its methodpropagate()
. The classCpoSolver
contains the actual implementation of this method, but also some others functions allowing to invoke more specialized functions. An advanced programming may require to explicitly create a CpoSolver instead of calling function at model level. Please refer to this class for more details.This function is available on DOcplexcloud and with local CPO solver with release number greater or equal to 12.7.0.
Parameters:  cnstr (Optional) – Optional constraint to be added to the model before invoking propagation. If not given, solving context is the default one that is defined in the module
 context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module
config
.  params (Optional) – Solving parameters (object of class
CpoParameters
) that overwrite those in the solving context.  (param) (Optional) – Any individual solving parameter as defined in class
CpoParameters
(for example TimeLimit, Workers, SearchType, etc).  (others) (Optional) – Any leaf attribute with the same name in the solving context (for example agent, trace_log, trace_cpo, etc).
Returns: Propagation result (object of class
CpoSolveResult
)Raises: CpoNotSupportedException
– if method not available in the solver agent.CpoException
– (or derived) if error.

refine_conflict
(**kwargs)[source]¶ This method identifies a minimal conflict for the infeasibility of the current model.
Given an infeasible model, the conflict refiner can identify conflicting constraints and variable domains within the model to help you identify the causes of the infeasibility. In this context, a conflict is a subset of the constraints and/or variable domains of the model which are mutually contradictory. Since the conflict is minimal, removal of any one of these constraints will remove that particular cause for infeasibility. There may be other conflicts in the model; consequently, repair of a given conflict does not guarantee feasibility of the remaining model.
Conflict refiner is controlled by the following parameters, that can be set as parameters of this method:
 ConflictRefinerBranchLimit
 ConflictRefinerFailLimit
 ConflictRefinerIterationLimit
 ConflictRefinerOnVariables
 ConflictRefinerTimeLimit
that are described in module
docplex.cp.parameters
.Note that the general TimeLimit parameter is used as a limiter for each conflict refiner iteration, but the global limitation in time must be set using ConflictRefinerTimeLimit that is infinite by default.
This method creates a new
CpoSolver
with given arguments, and then call its methodrefine_conflict()
. The classCpoSolver
contains the actual implementation of this method, but also some others functions allowing to invoke more specialized functions. An advanced programming may require to explicitly create a CpoSolver instead of calling function at model level. Please refer to this class for more details.This function is available on DOcplexcloud and with local CPO solver with release number greater or equal to 12.7.0.
Parameters:  context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module
config
.  params (Optional) – Solving parameters (object of class
CpoParameters
) that overwrite those in the solving context.  (param) (Optional) – Any individual solving parameter as defined in class
CpoParameters
(for example TimeLimit, Workers, SearchType, etc).  (others) (Optional) – Any leaf attribute with the same name in the solving context (for example agent, trace_log, trace_cpo, etc).
Returns: List of constraints that cause the conflict (object of class
CpoRefineConflictResult
)Raises: CpoNotSupportedException
– if method not available in the solver agent.CpoException
– (or derived) if error.

remove
(*expr)[source]¶ Remove one or several expressions from the model.
This method removes one or more CPO expression from the model.
The argument expr can be:
 any expression previously added to the model using method
add()
 an iterable of such expressions.
Expressions are removed from the toplevel expressions of the model. There is no attempst to search for subexpressions.
The expressions to remove are compared to existing ones using their id. If an expression is not found, it is ignored.
Parameters: expr – CPO expressions (constraint, boolean, objective, etc) to remove from the model, or iterable of expressions to remove from the model. Returns: Number of expressions actually removed from the model.  any expression previously added to the model using method

remove_expressions
(lexpr)[source]¶ Remove a list of expressions from the model.
DEPRECATED: use directly
remove()
instead, as it supports multiple or lists of expressions to remove.This method removes from the model all occurrences of the expressions given in the list. It removes only expressions at the toplevel, those added in the model using the method
add()
, it does not remove the expressions that are used as subexpression of another expression.This method is more efficient than calling
remove()
multiple times.Parameters: lexpr – List of expressions to remove from the model. Returns: Number of expressions actually removed from the model

remove_kpi
(kpi)[source]¶ Remove a Key Performance Indicator from the model.
Parameters: kpi – KPI expression, or KPI name

remove_solver_callback
(cback)[source]¶ Remove a CPO solver callback. previously added with
add_callback()
.Parameters: cback – Callback to remove.

remove_solver_listener
(lstnr)[source]¶ Remove a solver listener previously added with
add_listener()
.Parameters: lstnr – Listener to remove.

replace_expression
(oexpr, nexpr)[source]¶ In all model expressions, replace an expression by another.
This method goes across all model expressions tree and replace each occurrence of the expression to replace by the new expression. The comparison of the expression to replace is done by reference (it must be the same object)
Parameters:  oexpr – Expression to replace
 nexpr – Expression to put instead
Returns: Number of replacements done in the model

run_seeds
(nbrun, **kwargs)[source]¶ This method runs nbrun times the CP optimizer search with different random seeds and computes statistics from the result of these runs.
Result statistics are displayed on the log output that should be activated. If the appropriate configuration variable context.solver.add_log_to_solution is set to True (default), log is also available in the CpoRunResult result object, accessible as a string using the method
get_solver_log()
Each run of the solver is stopped according to single solve conditions (TimeLimit for example). Total run time is then expected to take nbruns times the duration of a single run.
This function is available only with local CPO solver with release number greater or equal to 12.8.
Parameters:  nbrun – Number of runs with different seeds.
 context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module
config
.  params (Optional) – Solving parameters (object of class
CpoParameters
) that overwrite those in the solving context.  (param) (Optional) – Any individual solving parameter as defined in class
CpoParameters
(for example TimeLimit, Workers, SearchType, etc).  (others) (Optional) – Any leaf attribute with the same name in the solving context (for example agent, trace_log, trace_cpo, etc).
Returns: Run result, object of class
CpoRunResult
.Raises: CpoNotSupportedException
– if method not available in the solver agent.CpoException
– (or derived) if error.

set_format_version
(ver)[source]¶ Set the expected version of the CPO format.
If the version is None (default), the model is generated with the most recent version. If the solver is not the most recent, the model may be rejected at solve time if a recent feature has been used. If the version is set, available features are checket at modeling time.
Parameters: ver – CPO format version

set_parameters
(params=None, **kwargs)[source]¶ Set the solving parameters associated to this model.
The argument params can be either:
 An object of the class
CpoParameters
. The parameters object is cloned and replaces the existing parameters associated to the model, if any.  A standard Python dictionary where keys are parameter names, and values parameter values. In this case, a CpoParameters object is created from the dictionary and then associated to the model.
 None, to release the parameters of this model.
If optional named arguments are added to this method, they are considered as additions to the parameters given in params, that is cloned prior to be modified. If params is None, a new
CpoParameters
is created.Parameters:  params (Optional) – Solving parameters, object of class
CpoParameters
, or a dictionary of parameters, or None to remove all parameters.  **kwargs (Optional) – Optional changes to the parameters.
Returns: The new CpoParameters object associated to this model.
 An object of the class

set_search_phases
(phases)[source]¶ Set a list of search phases
Parameters: phases – Array of search phases, or single phase

set_starting_point
(stpoint)[source]¶ Set a model starting point.
A starting point specifies a (possibly partial) solution that could be used by CP Optimizer to start the search. This starting point is represented by an object of class
CpoModelSolution
, with the following restrictions: Only integer and interval variables are taken into account. If present, all other elements are simply ignored.
 In integer variable, if the domain is not fixed to a single value, only a single range of values is allowed. If the variable domain is sparse, the range domain_min..domain_max is used.
An empty starting point can be created using method
create_empty_solution()
, and then filled using dedicated methodsadd_integer_var_solution()
andadd_interval_var_solution()
, or using indexed assignment as in the following example:mdl = CpoModel() a = integer_var(0, 3) b = interval_var(length=(1, 4)) . . . stp = mdl.create_empty_solution() stp[a] = 2 stp[b] = (2, 3, 4) mdl.set_starting_point(stp)
Starting point is available for CPO solver release greater or equal to 12.7.0.
Parameters: stpoint – Starting point, object of class CpoModelSolution

solve
(**kwargs)[source]¶ Solves the model.
This method solves the model using the appropriate
CpoSolver
created according to default solving context, possibly modified by the parameters of this method.The class
CpoSolver
contains the actual implementation of this method, but also some others functions allowing to invoke more specialized functions. An advanced programming may require to explicitly create a CpoSolver instead of calling function at model level. Please refer to this class for more details.All necessary solving parameters are taken from the solving context that is constructed from the following list of sources, each one overwriting the previous:
If an optional argument other than context or params is given to this method, it is searched in the context where its value is replaced by the new one. If not found, it is then considered as a solver parameter. In this case, only public parameters are allowed, except if the context attribute solver.enable_undocumented_params is set to True. This can be done directly when calling this method, as for example:
mdl.solve(enable_undocumented_params=True, MyPrivateParam=MyValue)
Parameters:  context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module
config
.  params (Optional) – Solving parameters (object of class
CpoParameters
) that overwrite those in the solving context.  (param) (Optional) – Any individual solving parameter as defined in class
CpoParameters
(for example TimeLimit, Workers, SearchType, etc).  (others) (Optional) – Any leaf attribute with the same name in the solving context (for example agent, trace_log, trace_cpo, etc).
Returns: Model solve result (object of class
CpoSolveResult
).Raises: CpoException
– (or derived) if error. context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module

start_search
(**kwargs)[source]¶ Start a new search sequence to retrieve multiple solutions of the model.
This method returns a new
CpoSolver
object that acts as an iterator of the different solutions of the model. All solutions can be retrieved using a loop like:lsols = mdl.start_search() for sol in lsols: sol.write()
A such solution iteration can be interrupted at any time by calling
end_search()
that returns a fail solution including the last solve status.Note that, to be sure to retrieve all solutions and only once each, recommended parameters are start_search(SearchType=’DepthFirst’, Workers=1)
Optional arguments are the same than those available in the method
solve()
Parameters:  context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module
config
.  params (Optional) – Solving parameters (object of class
CpoParameters
) that overwrite those in the solving context.  (param) (Optional) – Any individual solving parameter as defined in class
CpoParameters
(for example TimeLimit, Workers, SearchType, etc).  (others) (Optional) – Any leaf attribute with the same name in the solving context (for example agent, trace_log, trace_cpo, etc).
Returns: Object of class
CpoSolver
allowing to iterate over the different solutions.Raises: CpoException
– (or derived) if error. context (Optional) – Complete solving context.
If not given, solving context is the default one that is defined in the module

write_information
(out=None)[source]¶ Write various information about the model.
This method calls the method
get_statistics()
to retrieve information on the model, and then print it with source file name and modeling time.Parameters: out – Output stream or file name, default is sys.stdout.

class
docplex.cp.model.
CpoModelStatistics
(model=None, json=None)[source]¶ Bases:
object
This class represents model statistics information.
Constructor
Can be created either by giving source model, or json object.
Parameters:  model – (Optional) Source model
 json – (Optional) Json representation of this object

add
(other)[source]¶ Add other model statistics to this one
Parameters: other – Other model statistics, object of class CpoModelStatistics

get_number_of_constraints
()[source]¶ Return the number of constraints.
Returns: Number of constraints.

get_number_of_expressions
()[source]¶ Return the total number of root expressions.
Returns: Number of model root expressions.

get_number_of_variables
()[source]¶ Return the total number of variables.
The total number of variables includes:
 integer variables
 interval variables
 sequence variables
 state functions
 float variables
Returns: Total number of variables