Uses of Class com.google.ortools.constraintsolver.IntVar (com.google.ortools:ortools-java 9.0.9048 API)

Packages that use IntVar
Package	Description
com.google.ortools.constraintsolver

Uses of IntVar in com.google.ortools.constraintsolver

Subclasses of IntVar in com.google.ortools.constraintsolver
Modifier and Type	Class	Description
`class`	`BooleanVar`

Methods in com.google.ortools.constraintsolver that return IntVar
Modifier and Type	Method	Description
`IntVar`	RoutingModel.`activeVar(long index)`	Returns the active variable of the node corresponding to index.
`IntVar`	RoutingModel.`activeVehicleVar(int vehicle)`	Returns the active variable of the vehicle.
`IntVar`	RoutingModel.`applyLocks(long[] locks)`	Applies a lock chain to the next search.
`IntVar`	Pack.`assignVar(int var_index, int bin_index)`
`IntVar`	BaseIntExpr.`castToVar()`
`IntVar`	RoutingModel.`costVar()`	Returns the global cost variable which is being minimized.
`IntVar[]`	RoutingDimension.`cumuls()`	Like CumulVar(), TransitVar(), SlackVar() but return the whole variable vectors instead (indexed by int64_t var index).
`IntVar`	RoutingDimension.`cumulVar(long index)`	Get the cumul, transit and slack variables for the given node (given as int64_t var index).
`IntVar[]`	RoutingDimension.`fixed_transits()`
`IntVar`	RoutingDimension.`fixedTransitVar(long index)`
`IntVar`	Solver.IntegerCastInfo.`getVariable()`
`IntVar`	BooleanVar.`isDifferent(long constant)`
`IntVar`	IntVar.`isDifferent(long constant)`
`IntVar`	BooleanVar.`isEqual(long constant)`
`IntVar`	IntVar.`isEqual(long constant)`	IsEqual
`IntVar`	BooleanVar.`isGreaterOrEqual(long constant)`
`IntVar`	IntVar.`isGreaterOrEqual(long constant)`
`IntVar`	BooleanVar.`isLessOrEqual(long constant)`
`IntVar`	IntVar.`isLessOrEqual(long constant)`
`IntVar`	Solver.`makeBoolVar()`	MakeBoolVar will create a variable with a {0, 1} domain.
`IntVar`	Solver.`makeBoolVar(java.lang.String name)`	MakeBoolVar will create a variable with a {0, 1} domain.
`IntVar[]`	Solver.`makeBoolVarArray(int count)`
`IntVar[]`	Solver.`makeBoolVarArray(int count, java.lang.String name)`
`IntVar`	Solver.`makeIntConst(long val)`	IntConst will create a constant expression.
`IntVar`	Solver.`makeIntConst(long val, java.lang.String name)`	IntConst will create a constant expression.
`IntVar`	Solver.`makeIntVar(int[] values)`	MakeIntVar will create a variable with the given sparse domain.
`IntVar`	Solver.`makeIntVar(int[] values, java.lang.String name)`	MakeIntVar will create a variable with the given sparse domain.
`IntVar`	Solver.`makeIntVar(long[] values)`	MakeIntVar will create a variable with the given sparse domain.
`IntVar`	Solver.`makeIntVar(long[] values, java.lang.String name)`	MakeIntVar will create a variable with the given sparse domain.
`IntVar`	Solver.`makeIntVar(long min, long max)`	MakeIntVar will create the best range based int var for the bounds given.
`IntVar`	Solver.`makeIntVar(long min, long max, java.lang.String name)`	MakeIntVar will create the best range based int var for the bounds given.
`IntVar[]`	Solver.`makeIntVarArray(int count, long min, long max)`
`IntVar[]`	Solver.`makeIntVarArray(int count, long min, long max, java.lang.String name)`
`IntVar`	Solver.`makeIsBetweenVar(IntExpr v, long l, long u)`
`IntVar`	Solver.`makeIsDifferentCstVar(IntExpr var, long value)`	status var of (var != value)
`IntVar`	Solver.`makeIsDifferentCstVar(IntExpr v1, IntExpr v2)`	status var of (v1 != v2)
`IntVar`	Solver.`makeIsEqualCstVar(IntExpr var, long value)`	status var of (var == value)
`IntVar`	Solver.`makeIsEqualVar(IntExpr v1, IntExpr v2)`	status var of (v1 == v2)
`IntVar`	Solver.`makeIsGreaterCstVar(IntExpr var, long value)`	status var of (var > value)
`IntVar`	Solver.`makeIsGreaterOrEqualCstVar(IntExpr var, long value)`	status var of (var >= value)
`IntVar`	Solver.`makeIsGreaterOrEqualVar(IntExpr left, IntExpr right)`	status var of (left >= right)
`IntVar`	Solver.`makeIsGreaterVar(IntExpr left, IntExpr right)`	status var of (left > right)
`IntVar`	Solver.`makeIsLessCstVar(IntExpr var, long value)`	status var of (var < value)
`IntVar`	Solver.`makeIsLessOrEqualCstVar(IntExpr var, long value)`	status var of (var <= value)
`IntVar`	Solver.`makeIsLessOrEqualVar(IntExpr left, IntExpr right)`	status var of (left <= right)
`IntVar`	Solver.`makeIsLessVar(IntExpr left, IntExpr right)`	status var of (left < right)
`IntVar`	Solver.`makeIsMemberVar(IntExpr expr, int[] values)`
`IntVar`	Solver.`makeIsMemberVar(IntExpr expr, long[] values)`
`IntVar`	SequenceVar.`next(int index)`	Returns the next of the index_th interval of the sequence.
`IntVar[]`	RoutingModel.`nexts()`	Returns all next variables of the model, such that Nexts(i) is the next variable of the node corresponding to i.
`IntVar`	RoutingModel.`nextVar(long index)`	Returns the next variable of the node corresponding to index.
`IntVar`	Assignment.`objective()`
`IntVar`	Solver.`registerIntVar(IntVar var)`	Registers a new IntVar and wraps it inside a TraceIntVar if necessary.
`static IntVar[]`	mainJNI.`RoutingDimension_cumuls(long jarg1, RoutingDimension jarg1_)`
`static IntVar[]`	mainJNI.`RoutingDimension_fixed_transits(long jarg1, RoutingDimension jarg1_)`
`static IntVar[]`	mainJNI.`RoutingDimension_slacks(long jarg1, RoutingDimension jarg1_)`
`static IntVar[]`	mainJNI.`RoutingDimension_transits(long jarg1, RoutingDimension jarg1_)`
`static IntVar[]`	mainJNI.`RoutingModel_nexts(long jarg1, RoutingModel jarg1_)`
`static IntVar[]`	mainJNI.`RoutingModel_vehicleVars(long jarg1, RoutingModel jarg1_)`
`IntVar[]`	RoutingDimension.`slacks()`
`IntVar`	RoutingDimension.`slackVar(long index)`
`IntVar`	CastConstraint.`target_var()`
`IntVar[]`	RoutingDimension.`transits()`
`IntVar`	RoutingDimension.`transitVar(long index)`
`IntVar`	BaseIntExpr.`var()`
`IntVar`	Constraint.`var()`	Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied).
`IntVar`	IntExpr.`var()`	Creates a variable from the expression.
`IntVar`	IntVar.`var()`
`IntVar`	IntVarElement.`var()`
`IntVar`	IntVarLocalSearchFilter.`var(int index)`
`IntVar`	IntVarLocalSearchOperatorTemplate.`var(long index)`	Returns the variable of given index.
`IntVar`	OptimizeVar.`var()`	Returns the variable that is optimized.
`IntVar`	IntExpr.`varWithName(java.lang.String name)`	Creates a variable from the expression and set the name of the resulting var.
`IntVar`	RoutingModel.`VehicleCostsConsideredVar(int vehicle)`	Returns the variable specifying whether or not costs are considered for vehicle.
`IntVar`	RoutingModel.`vehicleVar(long index)`	Returns the vehicle variable of the node corresponding to index.
`IntVar[]`	RoutingModel.`vehicleVars()`	Returns all vehicle variables of the model, such that VehicleVars(i) is the vehicle variable of the node corresponding to i.

Methods in com.google.ortools.constraintsolver with parameters of type IntVar
Modifier and Type	Method	Description
`void`	Assignment.`activate(IntVar var)`
`boolean`	Assignment.`activated(IntVar var)`
`IntVarElement`	Assignment.`add(IntVar var)`
`void`	Assignment.`add(IntVar[] vars)`
`IntVarElement`	AssignmentIntContainer.`add(IntVar var)`
`void`	SolutionCollector.`add(IntVar var)`	Add API.
`void`	SolutionCollector.`add(IntVar[] vars)`
`IntVarElement`	AssignmentIntContainer.`addAtPosition(IntVar var, int position)`	Advanced usage: Adds element at a given position; position has to have been allocated with AssignmentContainer::Resize() beforehand.
`void`	Solver.`addCastConstraint(CastConstraint constraint, IntVar target_var, IntExpr expr)`	Adds 'constraint' to the solver and marks it as a cast constraint, that is, a constraint created calling Var() on an expression.
`void`	Pack.`addCountAssignedItemsDimension(IntVar count_var)`	This dimension links 'count_var' to the actual number of items assigned to a bin in the pack.
`void`	Pack.`addCountUsedBinDimension(IntVar count_var)`	This dimension links 'count_var' to the actual number of bins used in the pack.
`void`	SymmetryBreaker.`addIntegerVariableEqualValueClause(IntVar var, long value)`
`void`	SymmetryBreaker.`addIntegerVariableGreaterOrEqualValueClause(IntVar var, long value)`
`void`	SymmetryBreaker.`addIntegerVariableLessOrEqualValueClause(IntVar var, long value)`
`void`	Assignment.`addObjective(IntVar v)`
`void`	SolutionCollector.`addObjective(IntVar objective)`
`void`	Pack.`addSumVariableWeightsLessOrEqualConstantDimension(IntVar[] usage, long[] capacity)`	This dimension imposes: forall b in bins, sum (i in items: usage[i] * is_assigned(i, b)) <= capacity[b] where is_assigned(i, b) is true if and only if item i is assigned to the bin b. This can be used to model shapes of items by linking variables of the same item on parallel dimensions with an allowed assignment constraint.
`void`	IntVarLocalSearchHandler.`addToAssignment(IntVar var, long value, boolean active, SWIGTYPE_p_std__vectorT_int_t assignment_indices, long index, Assignment assignment)`
`void`	RoutingModel.`addToAssignment(IntVar var)`	Adds an extra variable to the vehicle routing assignment.
`void`	RoutingModel.`addVariableMaximizedByFinalizer(IntVar var)`	Adds a variable to maximize in the solution finalizer (see above for information on the solution finalizer).
`void`	RoutingModel.`addVariableMinimizedByFinalizer(IntVar var)`	Adds a variable to minimize in the solution finalizer.
`void`	RoutingModel.`addVariableTargetToFinalizer(IntVar var, long target)`	Add a variable to set the closest possible to the target value in the solution finalizer.
`void`	IntVarLocalSearchFilter.`addVars(IntVar[] vars)`	Add variables to "track" to the filter.
`void`	IntVarLocalSearchOperatorTemplate.`addVars(IntVar[] vars)`
`void`	Pack.`addWeightedSumEqualVarDimension(long[] weights, IntVar[] loads)`	This dimension imposes that for all bins b, the weighted sum (weights[i]) of all objects i assigned to 'b' is equal to loads[b].
`void`	Pack.`addWeightedSumEqualVarDimension(java.util.function.LongBinaryOperator weights, IntVar[] loads)`	This dimension imposes that for all bins b, the weighted sum (weights->Run(i, b)) of all objects i assigned to 'b' is equal to loads[b].
`void`	Pack.`addWeightedSumOfAssignedDimension(long[] weights, IntVar cost_var)`	This dimension enforces that cost_var == sum of weights[i] for all objects 'i' assigned to a bin.
`void`	RoutingModel.`AddWeightedVariableMinimizedByFinalizer(IntVar var, long cost)`	Adds a variable to minimize in the solution finalizer, with a weighted priority: the higher the more priority it has.
`static boolean`	main.`areAllBooleans(IntVar[] vars)`
`static boolean`	mainJNI.`areAllBooleans(IntVar[] jarg1)`
`static boolean`	main.`areAllBound(IntVar[] vars)`
`static boolean`	mainJNI.`areAllBound(IntVar[] jarg1)`
`static boolean`	main.`areAllBoundTo(IntVar[] vars, long value)`	Returns true if all variables are assigned to 'value'.
`static boolean`	mainJNI.`areAllBoundTo(IntVar[] jarg1, long jarg2)`
`static void`	mainJNI.`Assignment_activate__SWIG_0(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static boolean`	mainJNI.`Assignment_activated__SWIG_0(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`Assignment_add__SWIG_0(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`Assignment_add__SWIG_1(long jarg1, Assignment jarg1_, IntVar[] jarg2)`
`static void`	mainJNI.`Assignment_addObjective(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static boolean`	mainJNI.`Assignment_bound(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static boolean`	mainJNI.`Assignment_contains__SWIG_0(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`Assignment_deactivate__SWIG_0(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`Assignment_fastAdd__SWIG_0(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`Assignment_max(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`Assignment_min(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`Assignment_setMax(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`Assignment_setMin(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`Assignment_setRange(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_, long jarg3, long jarg4)`
`static void`	mainJNI.`Assignment_setValue(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Assignment_value(long jarg1, Assignment jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`AssignmentIntContainer_add(long jarg1, AssignmentIntContainer jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`AssignmentIntContainer_addAtPosition(long jarg1, AssignmentIntContainer jarg1_, long jarg2, IntVar jarg2_, int jarg3)`
`static boolean`	mainJNI.`AssignmentIntContainer_contains(long jarg1, AssignmentIntContainer jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`AssignmentIntContainer_element__SWIG_0(long jarg1, AssignmentIntContainer jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`AssignmentIntContainer_fastAdd(long jarg1, AssignmentIntContainer jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`AssignmentIntContainer_mutableElement__SWIG_0(long jarg1, AssignmentIntContainer jarg1_, long jarg2, IntVar jarg2_)`
`boolean`	Assignment.`bound(IntVar var)`
`IntExpr`	Solver.`castExpression(IntVar var)`	Internal.
`boolean`	Assignment.`contains(IntVar var)`
`boolean`	AssignmentIntContainer.`contains(IntVar var)`
`void`	Assignment.`deactivate(IntVar var)`
`static void`	mainJNI.`DecisionVisitor_visitSetVariableValue(long jarg1, DecisionVisitor jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`DecisionVisitor_visitSetVariableValueSwigExplicitDecisionVisitor(long jarg1, DecisionVisitor jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`DecisionVisitor_visitSplitVariableDomain(long jarg1, DecisionVisitor jarg1_, long jarg2, IntVar jarg2_, long jarg3, boolean jarg4)`
`static void`	mainJNI.`DecisionVisitor_visitSplitVariableDomainSwigExplicitDecisionVisitor(long jarg1, DecisionVisitor jarg1_, long jarg2, IntVar jarg2_, long jarg3, boolean jarg4)`
`IntVarElement`	AssignmentIntContainer.`element(IntVar var)`
`void`	PropagationMonitor.`endProcessingIntegerVariable(IntVar var)`
`IntVarElement`	Assignment.`fastAdd(IntVar var)`	Adds without checking if variable has been previously added.
`IntVarElement`	AssignmentIntContainer.`fastAdd(IntVar var)`	Adds element without checking its presence in the container.
`IntExpr`	ModelCache.`findVarArrayConstantArrayExpression(IntVar[] vars, long[] values, int type)`	Var Array Constant Array Expressions.
`IntExpr`	ModelCache.`findVarArrayConstantExpression(IntVar[] vars, long value, int type)`	Var Array Constant Expressions.
`IntExpr`	ModelCache.`findVarArrayExpression(IntVar[] vars, int type)`	Var Array Expressions.
`IntExpr`	ModelCache.`findVarConstantArrayExpression(IntVar var, long[] values, int type)`	Var Constant Array Expressions.
`Constraint`	ModelCache.`findVarConstantConstantConstraint(IntVar var, long value1, long value2, int type)`	Var Constant Constant Constraints.
`IntExpr`	ModelCache.`findVarConstantConstantExpression(IntVar var, long value1, long value2, int type)`	Var Constant Constant Expressions.
`Constraint`	ModelCache.`findVarConstantConstraint(IntVar var, long value, int type)`	Var Constant Constraints.
`protected static long`	IntVar.`getCPtr(IntVar obj)`
`int`	IntVarLocalSearchFilter.`index(IntVar var)`
`void`	ModelCache.`insertVarArrayConstantArrayExpression(IntExpr expression, IntVar[] var, long[] values, int type)`
`void`	ModelCache.`insertVarArrayConstantExpression(IntExpr expression, IntVar[] var, long value, int type)`
`void`	ModelCache.`insertVarArrayExpression(IntExpr expression, IntVar[] vars, int type)`
`void`	ModelCache.`insertVarConstantArrayExpression(IntExpr expression, IntVar var, long[] values, int type)`
`void`	ModelCache.`insertVarConstantConstantConstraint(Constraint ct, IntVar var, long value1, long value2, int type)`
`void`	ModelCache.`insertVarConstantConstantExpression(IntExpr expression, IntVar var, long value1, long value2, int type)`
`void`	ModelCache.`insertVarConstantConstraint(Constraint ct, IntVar var, long value, int type)`
`static void`	mainJNI.`IntVar_accept(long jarg1, IntVar jarg1_, long jarg2, ModelVisitor jarg2_)`
`static boolean`	mainJNI.`IntVar_contains(long jarg1, IntVar jarg1_, long jarg2)`
`static int`	mainJNI.`IntVar_index(long jarg1, IntVar jarg1_)`
`static long`	mainJNI.`IntVar_isDifferent(long jarg1, IntVar jarg1_, long jarg2)`
`static long`	mainJNI.`IntVar_isEqual(long jarg1, IntVar jarg1_, long jarg2)`
`static long`	mainJNI.`IntVar_isGreaterOrEqual(long jarg1, IntVar jarg1_, long jarg2)`
`static long`	mainJNI.`IntVar_isLessOrEqual(long jarg1, IntVar jarg1_, long jarg2)`
`static boolean`	mainJNI.`IntVar_isVar(long jarg1, IntVar jarg1_)`
`static long`	mainJNI.`IntVar_makeDomainIterator(long jarg1, IntVar jarg1_, boolean jarg2)`
`static long`	mainJNI.`IntVar_makeHoleIterator(long jarg1, IntVar jarg1_, boolean jarg2)`
`static long`	mainJNI.`IntVar_oldMax(long jarg1, IntVar jarg1_)`
`static long`	mainJNI.`IntVar_oldMin(long jarg1, IntVar jarg1_)`
`static void`	mainJNI.`IntVar_removeInterval(long jarg1, IntVar jarg1_, long jarg2, long jarg3)`
`static void`	mainJNI.`IntVar_removeValue(long jarg1, IntVar jarg1_, long jarg2)`
`static void`	mainJNI.`IntVar_removeValues(long jarg1, IntVar jarg1_, long[] jarg2)`
`static void`	mainJNI.`IntVar_setValue(long jarg1, IntVar jarg1_, long[] jarg2)`
`static long`	mainJNI.`IntVar_size(long jarg1, IntVar jarg1_)`
`static long`	mainJNI.`IntVar_value(long jarg1, IntVar jarg1_)`
`static long`	mainJNI.`IntVar_var(long jarg1, IntVar jarg1_)`
`static int`	mainJNI.`IntVar_varType(long jarg1, IntVar jarg1_)`
`static void`	mainJNI.`IntVar_whenBound__SWIG_0(long jarg1, IntVar jarg1_, long jarg2, Demon jarg2_)`
`static void`	mainJNI.`IntVar_whenBound__SWIG_1(long jarg1, IntVar jarg1_, java.lang.Runnable jarg2)`
`static void`	mainJNI.`IntVar_whenDomain__SWIG_0(long jarg1, IntVar jarg1_, long jarg2, Demon jarg2_)`
`static void`	mainJNI.`IntVar_whenDomain__SWIG_1(long jarg1, IntVar jarg1_, java.lang.Runnable jarg2)`
`static void`	mainJNI.`IntVarElement_reset(long jarg1, IntVarElement jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`IntVarLocalSearchFilter_addVars(long jarg1, IntVarLocalSearchFilter jarg1_, IntVar[] jarg2)`
`static int`	mainJNI.`IntVarLocalSearchFilter_index(long jarg1, IntVarLocalSearchFilter jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`IntVarLocalSearchHandler_addToAssignment(long jarg1, IntVarLocalSearchHandler jarg1_, long jarg2, IntVar jarg2_, long jarg3, boolean jarg4, long jarg5, long jarg6, long jarg7, Assignment jarg7_)`
`static boolean`	mainJNI.`IntVarLocalSearchHandler_ValueFromAssignment(long jarg1, IntVarLocalSearchHandler jarg1_, long jarg2, Assignment jarg2_, long jarg3, IntVar jarg3_, long jarg4, int[] jarg5)`
`static void`	mainJNI.`IntVarLocalSearchOperatorTemplate_addVars(long jarg1, IntVarLocalSearchOperatorTemplate jarg1_, IntVar[] jarg2)`
`Constraint`	Solver.`makeAbsEquality(IntVar var, IntVar abs_var)`	Creates the constraint abs(var) == abs_var.
`Constraint`	Solver.`makeAllDifferent(IntVar[] vars)`	All variables are pairwise different.
`Constraint`	Solver.`makeAllDifferent(IntVar[] vars, boolean stronger_propagation)`	All variables are pairwise different.
`Constraint`	Solver.`makeAllDifferentExcept(IntVar[] vars, long escape_value)`	All variables are pairwise different, unless they are assigned to the escape value.
`Constraint`	Solver.`makeAllowedAssignment(IntVar[] vars, IntTupleSet tuples)`	This method creates a constraint where the graph of the relation between the variables is given in extension.
`Decision`	Solver.`makeAssignVariablesValues(IntVar[] vars, long[] values)`
`Decision`	Solver.`makeAssignVariableValue(IntVar var, long val)`	Decisions.
`Decision`	Solver.`MakeAssignVariableValueOrDoNothing(IntVar var, long value)`
`Decision`	Solver.`makeAssignVariableValueOrFail(IntVar var, long value)`
`Constraint`	Solver.`makeCircuit(IntVar[] nexts)`	Force the "nexts" variable to create a complete Hamiltonian path.
`IntExpr`	Solver.`makeConditionalExpression(IntVar condition, IntExpr expr, long unperformed_value)`	Conditional Expr condition ? expr : unperformed_value
`Constraint`	Solver.`makeCount(IntVar[] vars, long value, long max_count)`	\|{i \| vars[i] == value}\| == max_count
`Constraint`	Solver.`makeCount(IntVar[] vars, long value, IntVar max_count)`	\|{i \| vars[i] == value}\| == max_count
`Constraint`	Solver.`makeCumulative(IntervalVar[] intervals, int[] demands, IntVar capacity, java.lang.String name)`	This constraint enforces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values.
`Constraint`	Solver.`makeCumulative(IntervalVar[] intervals, long[] demands, IntVar capacity, java.lang.String name)`	This constraint forces that, for any integer t, the sum of the demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should only contain non-negative values.
`Constraint`	Solver.`makeCumulative(IntervalVar[] intervals, IntVar[] demands, long capacity, java.lang.String name)`	This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
`Constraint`	Solver.`makeCumulative(IntervalVar[] intervals, IntVar[] demands, IntVar capacity, java.lang.String name)`	This constraint enforces that, for any integer t, the sum of demands corresponding to an interval containing t does not exceed the given capacity. Intervals and demands should be vectors of equal size. Demands should be positive.
`DecisionBuilder`	Solver.`makeDecisionBuilderFromAssignment(Assignment assignment, DecisionBuilder db, IntVar[] vars)`	Returns a decision builder for which the left-most leaf corresponds to assignment, the rest of the tree being explored using 'db'.
`DecisionBuilder`	Solver.`makeDefaultPhase(IntVar[] vars)`
`DecisionBuilder`	Solver.`makeDefaultPhase(IntVar[] vars, DefaultPhaseParameters parameters)`
`Constraint`	Solver.`makeDelayedPathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, IntVar[] transits)`	Delayed version of the same constraint: propagation on the nexts variables is delayed until all constraints have propagated.
`Constraint`	Solver.`makeDeviation(IntVar[] vars, IntVar deviation_var, long total_sum)`	Deviation constraint: sum_i \|n * vars[i] - total_sum\| <= deviation_var and sum_i vars[i] == total_sum n = #vars
`Constraint`	Solver.`makeDistribute(IntVar[] vars, int[] card_min, int[] card_max)`	Aggregated version of count with bounded cardinalities: forall j in 0 ..
`Constraint`	Solver.`makeDistribute(IntVar[] vars, int[] values, int[] card_min, int[] card_max)`	Aggregated version of count with bounded cardinalities: forall j in 0 ..
`Constraint`	Solver.`makeDistribute(IntVar[] vars, int[] values, IntVar[] cards)`	Aggregated version of count: \|{i \| v[i] == values[j]}\| == cards[j]
`Constraint`	Solver.`makeDistribute(IntVar[] vars, long[] card_min, long[] card_max)`	Aggregated version of count with bounded cardinalities: forall j in 0 ..
`Constraint`	Solver.`makeDistribute(IntVar[] vars, long[] values, long[] card_min, long[] card_max)`	Aggregated version of count with bounded cardinalities: forall j in 0 ..
`Constraint`	Solver.`makeDistribute(IntVar[] vars, long[] values, IntVar[] cards)`	Aggregated version of count: \|{i \| v[i] == values[j]}\| == cards[j]
`Constraint`	Solver.`makeDistribute(IntVar[] vars, long card_min, long card_max, long card_size)`	Aggregated version of count with bounded cardinalities: forall j in 0 ..
`Constraint`	Solver.`makeDistribute(IntVar[] vars, IntVar[] cards)`	Aggregated version of count: \|{i \| v[i] == j}\| == cards[j]
`IntExpr`	Solver.`makeElement(int[] values, IntVar index)`	values[index]
`IntExpr`	Solver.`makeElement(long[] values, IntVar index)`	values[index]
`IntExpr`	Solver.`makeElement(IntVar[] vars, IntVar index)`	vars[expr]
`IntExpr`	Solver.`makeElement(java.util.function.LongBinaryOperator values, IntVar index1, IntVar index2)`	2D version of function-based element expression, values(expr1, expr2).
`IntExpr`	Solver.`makeElement(java.util.function.LongUnaryOperator values, IntVar index)`	Function-based element.
`Constraint`	Solver.`makeElementEquality(int[] vals, IntVar index, IntVar target)`
`Constraint`	Solver.`makeElementEquality(long[] vals, IntVar index, IntVar target)`
`Constraint`	Solver.`makeElementEquality(IntVar[] vars, IntVar index, long target)`
`Constraint`	Solver.`makeElementEquality(IntVar[] vars, IntVar index, IntVar target)`
`IntervalVar`	Solver.`makeFixedDurationIntervalVar(IntVar start_variable, long duration, IntVar performed_variable, java.lang.String name)`	Creates an interval var with a fixed duration, and performed_variable. The duration must be greater than 0.
`IntervalVar`	Solver.`makeFixedDurationIntervalVar(IntVar start_variable, long duration, java.lang.String name)`	Creates a performed interval var with a fixed duration.
`SearchMonitor`	Solver.`makeGenericTabuSearch(boolean maximize, IntVar v, long step, IntVar[] tabu_vars, long forbid_tenure)`	Creates a Tabu Search based on the vars \|vars\|. A solution is "tabu" if all the vars in \|vars\| keep their value.
`SearchMonitor`	Solver.`makeGuidedLocalSearch(boolean maximize, IntVar objective, LongTernaryOperator objective_function, long step, IntVar[] vars, IntVar[] secondary_vars, double penalty_factor)`
`SearchMonitor`	Solver.`makeGuidedLocalSearch(boolean maximize, IntVar objective, java.util.function.LongBinaryOperator objective_function, long step, IntVar[] vars, double penalty_factor)`	Creates a Guided Local Search monitor. Description here: http://en.wikipedia.org/wiki/Guided_Local_Search
`Constraint`	Solver.`makeIfThenElseCt(IntVar condition, IntExpr then_expr, IntExpr else_expr, IntVar target_var)`	Special cases with arrays of size two.
`ImprovementSearchLimit`	Solver.`MakeImprovementLimit(IntVar objective_var, boolean maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance)`	Limits the search based on the improvements of 'objective_var'.
`IntExpr`	Solver.`makeIndexExpression(IntVar[] vars, long value)`	Returns the expression expr such that vars[expr] == value. It assumes that vars are all different.
`Constraint`	Solver.`makeIndexOfConstraint(IntVar[] vars, IntVar index, long target)`	This constraint is a special case of the element constraint with an array of integer variables, where the variables are all different and the index variable is constrained such that vars[index] == target.
`Constraint`	Solver.`makeIndexOfFirstMaxValueConstraint(IntVar index, IntVar[] vars)`	Creates a constraint that binds the index variable to the index of the first variable with the maximum value.
`Constraint`	Solver.`makeIndexOfFirstMinValueConstraint(IntVar index, IntVar[] vars)`	Creates a constraint that binds the index variable to the index of the first variable with the minimum value.
`Constraint`	Solver.`makeInversePermutationConstraint(IntVar[] left, IntVar[] right)`	Creates a constraint that enforces that 'left' and 'right' both represent permutations of [0..left.size()-1], and that 'right' is the inverse permutation of 'left', i.e.
`Constraint`	Solver.`makeIsBetweenCt(IntExpr expr, long l, long u, IntVar b)`	b == (l <= expr <= u)
`Constraint`	Solver.`makeIsDifferentCstCt(IntExpr var, long value, IntVar boolvar)`	boolvar == (var != value)
`Constraint`	Solver.`makeIsDifferentCstCt(IntExpr v1, IntExpr v2, IntVar b)`	b == (v1 != v2)
`Constraint`	Solver.`makeIsEqualCstCt(IntExpr var, long value, IntVar boolvar)`	boolvar == (var == value)
`Constraint`	Solver.`makeIsEqualVar(IntExpr v1, IntExpr v2, IntVar b)`	b == (v1 == v2)
`Constraint`	Solver.`makeIsGreaterCstCt(IntExpr v, long c, IntVar b)`	b == (v > c)
`Constraint`	Solver.`makeIsGreaterCt(IntExpr left, IntExpr right, IntVar b)`	b == (left > right)
`Constraint`	Solver.`makeIsGreaterOrEqualCstCt(IntExpr var, long value, IntVar boolvar)`	boolvar == (var >= value)
`Constraint`	Solver.`makeIsGreaterOrEqualCt(IntExpr left, IntExpr right, IntVar b)`	b == (left >= right)
`Constraint`	Solver.`makeIsLessCstCt(IntExpr v, long c, IntVar b)`	b == (v < c)
`Constraint`	Solver.`makeIsLessCt(IntExpr left, IntExpr right, IntVar b)`	b == (left < right)
`Constraint`	Solver.`makeIsLessOrEqualCstCt(IntExpr var, long value, IntVar boolvar)`	boolvar == (var <= value)
`Constraint`	Solver.`makeIsLessOrEqualCt(IntExpr left, IntExpr right, IntVar b)`	b == (left <= right)
`Constraint`	Solver.`makeIsMemberCt(IntExpr expr, int[] values, IntVar boolvar)`
`Constraint`	Solver.`makeIsMemberCt(IntExpr expr, long[] values, IntVar boolvar)`	boolvar == (expr in set)
`Constraint`	Solver.`makeLexicalLess(IntVar[] left, IntVar[] right)`	Creates a constraint that enforces that left is lexicographically less than right.
`Constraint`	Solver.`makeLexicalLessOrEqual(IntVar[] left, IntVar[] right)`	Creates a constraint that enforces that left is lexicographically less than or equal to right.
`DecisionBuilder`	Solver.`makeLocalSearchPhase(IntVar[] vars, DecisionBuilder first_solution, DecisionBuilder first_solution_sub_decision_builder, LocalSearchPhaseParameters parameters)`	Variant with a sub_decison_builder specific to the first solution.
`DecisionBuilder`	Solver.`makeLocalSearchPhase(IntVar[] vars, DecisionBuilder first_solution, LocalSearchPhaseParameters parameters)`
`LocalSearchPhaseParameters`	Solver.`makeLocalSearchPhaseParameters(IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder)`	Local Search Phase Parameters
`LocalSearchPhaseParameters`	Solver.`makeLocalSearchPhaseParameters(IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit)`
`LocalSearchPhaseParameters`	Solver.`makeLocalSearchPhaseParameters(IntVar objective, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit, LocalSearchFilterManager filter_manager)`
`LocalSearchPhaseParameters`	Solver.`makeLocalSearchPhaseParameters(IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder)`
`LocalSearchPhaseParameters`	Solver.`makeLocalSearchPhaseParameters(IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit)`
`LocalSearchPhaseParameters`	Solver.`makeLocalSearchPhaseParameters(IntVar objective, SolutionPool pool, LocalSearchOperator ls_operator, DecisionBuilder sub_decision_builder, RegularLimit limit, LocalSearchFilterManager filter_manager)`
`Constraint`	Solver.`makeMapDomain(IntVar var, IntVar[] actives)`	This constraint maps the domain of 'var' onto the array of variables 'actives'.
`IntExpr`	Solver.`makeMax(IntVar[] vars)`	std::max(vars)
`Constraint`	Solver.`makeMaxEquality(IntVar[] vars, IntVar max_var)`
`OptimizeVar`	Solver.`makeMaximize(IntVar v, long step)`	Creates a maximization objective.
`IntExpr`	Solver.`makeMin(IntVar[] vars)`	std::min(vars)
`Constraint`	Solver.`makeMinEquality(IntVar[] vars, IntVar min_var)`
`OptimizeVar`	Solver.`makeMinimize(IntVar v, long step)`	Creates a minimization objective.
`IntExpr`	Solver.`makeMonotonicElement(java.util.function.LongUnaryOperator values, boolean increasing, IntVar index)`	Function based element.
`LocalSearchOperator`	Solver.`makeMoveTowardTargetOperator(IntVar[] variables, long[] target_values)`	Creates a local search operator that tries to move the assignment of some variables toward a target.
`Constraint`	Solver.`makeNoCycle(IntVar[] nexts, IntVar[] active)`	Prevent cycles.
`Constraint`	Solver.`makeNoCycle(IntVar[] nexts, IntVar[] active, java.util.function.LongPredicate sink_handler)`	Prevent cycles.
`Constraint`	Solver.`makeNoCycle(IntVar[] nexts, IntVar[] active, java.util.function.LongPredicate sink_handler, boolean assume_paths)`
`Constraint`	Solver.`makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, int[] x_size, int[] y_size)`
`Constraint`	Solver.`makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, long[] x_size, long[] y_size)`
`Constraint`	Solver.`makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, IntVar[] x_size, IntVar[] y_size)`	This constraint states that all the boxes must not overlap. The coordinates of box i are: (x_vars[i], y_vars[i]), (x_vars[i], y_vars[i] + y_size[i]), (x_vars[i] + x_size[i], y_vars[i]), (x_vars[i] + x_size[i], y_vars[i] + y_size[i]). The sizes must be non-negative.
`Constraint`	Solver.`makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, int[] x_size, int[] y_size)`
`Constraint`	Solver.`makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, long[] x_size, long[] y_size)`
`Constraint`	Solver.`makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, IntVar[] x_size, IntVar[] y_size)`	This constraint states that all the boxes must not overlap. The coordinates of box i are: (x_vars[i], y_vars[i]), (x_vars[i], y_vars[i] + y_size[i]), (x_vars[i] + x_size[i], y_vars[i]), (x_vars[i] + x_size[i], y_vars[i] + y_size[i]). The sizes must be positive. Boxes with a zero dimension can be placed anywhere.
`Constraint`	Solver.`makeNullIntersect(IntVar[] first_vars, IntVar[] second_vars)`	Creates a constraint that states that all variables in the first vector are different from all variables in the second group.
`Constraint`	Solver.`makeNullIntersectExcept(IntVar[] first_vars, IntVar[] second_vars, long escape_value)`	Creates a constraint that states that all variables in the first vector are different from all variables from the second group, unless they are assigned to the escape value.
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, int op)`	Local Search Operators.
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, int op)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, LongTernaryOperator evaluator, int op)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, LongTernaryOperator evaluator, int op)`
`OptimizeVar`	Solver.`makeOptimize(boolean maximize, IntVar v, long step)`	Creates a objective with a given sense (true = maximization).
`Pack`	Solver.`makePack(IntVar[] vars, int number_of_bins)`	This constraint packs all variables onto 'number_of_bins' variables.
`Constraint`	Solver.`makePathConnected(IntVar[] nexts, long[] sources, long[] sinks, IntVar[] status)`	Constraint enforcing that status[i] is true iff there's a path defined on next variables from sources[i] to sinks[i]. Check whether more propagation is needed.
`Constraint`	Solver.`makePathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, IntVar[] transits)`	Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transits[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem.
`Constraint`	Solver.`makePathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, IntVar[] slacks, java.util.function.LongBinaryOperator transit_evaluator)`	Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]) + slacks[i]. Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
`Constraint`	Solver.`makePathCumul(IntVar[] nexts, IntVar[] active, IntVar[] cumuls, java.util.function.LongBinaryOperator transit_evaluator)`	Creates a constraint which accumulates values along a path such that: cumuls[next[i]] = cumuls[i] + transit_evaluator(i, next[i]). Active variables indicate if the corresponding next variable is active; this could be useful to model unperformed nodes in a routing problem. Ownership of transit_evaluator is taken and it must be a repeatable callback.
`Constraint`	RoutingModel.`MakePathSpansAndTotalSlacks(RoutingDimension dimension, IntVar[] spans, IntVar[] total_slacks)`	For every vehicle of the routing model: - if total_slacks[vehicle] is not nullptr, constrains it to be the sum of slacks on that vehicle, that is, dimension->CumulVar(end) - dimension->CumulVar(start) - sum_{node in path of vehicle} dimension->FixedTransitVar(node). - if spans[vehicle] is not nullptr, constrains it to be dimension->CumulVar(end) - dimension->CumulVar(start) This does stronger propagation than a decomposition, and takes breaks into account.
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, int var_str, int val_str)`	Phases on IntVar arrays. for all other functions that have several homonyms in this .h).
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, int var_str, LongTernaryPredicate var_val1_val2_comparator)`	var_val1_val2_comparator(var, val1, val2) is true iff assigning value "val1" to variable "var" is better than assigning value "val2".
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, int var_str, java.util.function.LongBinaryOperator value_evaluator)`
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, int var_str, java.util.function.LongBinaryOperator value_evaluator, java.util.function.LongUnaryOperator tie_breaker)`
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, java.util.function.LongBinaryOperator eval, int str)`	Returns a decision builder which assigns values to variables which minimize the values returned by the evaluator.
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, java.util.function.LongBinaryOperator eval, java.util.function.LongUnaryOperator tie_breaker, int str)`	Returns a decision builder which assigns values to variables which minimize the values returned by the evaluator.
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, java.util.function.LongUnaryOperator var_evaluator, int val_str)`
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, java.util.function.LongUnaryOperator var_evaluator, java.util.function.LongBinaryOperator value_evaluator)`
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, java.util.function.LongUnaryOperator var_evaluator, java.util.function.LongBinaryOperator value_evaluator, java.util.function.LongUnaryOperator tie_breaker)`
`DecisionBuilder`	Solver.`makePhase(IntVar v0, int var_str, int val_str)`	Shortcuts for small arrays.
`DecisionBuilder`	Solver.`makePhase(IntVar v0, IntVar v1, int var_str, int val_str)`
`DecisionBuilder`	Solver.`makePhase(IntVar v0, IntVar v1, IntVar v2, int var_str, int val_str)`
`DecisionBuilder`	Solver.`makePhase(IntVar v0, IntVar v1, IntVar v2, IntVar v3, int var_str, int val_str)`
`LocalSearchOperator`	Solver.`makeRandomLnsOperator(IntVar[] vars, int number_of_variables)`	Creates a large neighborhood search operator which creates fragments (set of relaxed variables) with up to number_of_variables random variables (sampling with replacement is performed meaning that at most number_of_variables variables are selected).
`LocalSearchOperator`	Solver.`makeRandomLnsOperator(IntVar[] vars, int number_of_variables, int seed)`
`IntExpr`	Solver.`makeScalProd(IntVar[] vars, int[] coefs)`	scalar product
`IntExpr`	Solver.`makeScalProd(IntVar[] vars, long[] coefs)`	scalar product
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, int[] coefficients, long cst)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, int[] coefficients, IntVar target)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, long[] coefficients, long cst)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, long[] coefficients, IntVar target)`
`Constraint`	Solver.`makeScalProdGreaterOrEqual(IntVar[] vars, int[] coeffs, long cst)`
`Constraint`	Solver.`makeScalProdGreaterOrEqual(IntVar[] vars, long[] coeffs, long cst)`
`Constraint`	Solver.`makeScalProdLessOrEqual(IntVar[] vars, int[] coefficients, long cst)`
`Constraint`	Solver.`makeScalProdLessOrEqual(IntVar[] vars, long[] coefficients, long cst)`
`SearchMonitor`	Solver.`makeSearchLog(int branch_period, IntVar var)`	At each solution, this monitor also display the var value.
`SearchMonitor`	Solver.`makeSearchLog(int branch_period, IntVar var, java.util.function.Supplier<java.lang.String> display_callback)`	At each solution, this monitor will display the 'var' value and the result of `display_callback`.
`static DecisionBuilder`	main.`makeSetValuesFromTargets(Solver solver, IntVar[] variables, long[] targets)`	A decision builder which tries to assign values to variables as close as possible to target values first.
`static long`	mainJNI.`makeSetValuesFromTargets(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3)`
`SearchMonitor`	Solver.`makeSimulatedAnnealing(boolean maximize, IntVar v, long step, long initial_temperature)`	Creates a Simulated Annealing monitor.
`Constraint`	Solver.`makeSortingConstraint(IntVar[] vars, IntVar[] sorted)`	Creates a constraint binding the arrays of variables "vars" and "sorted_vars": sorted_vars[0] must be equal to the minimum of all variables in vars, and so on: the value of sorted_vars[i] must be equal to the i-th value of variables invars. This constraint propagates in both directions: from "vars" to "sorted_vars" and vice-versa. Behind the scenes, this constraint maintains that: - sorted is always increasing. - whatever the values of vars, there exists a permutation that injects its values into the sorted variables. For more info, please have a look at: https://mpi-inf.mpg.de/~mehlhorn/ftp/Mehlhorn-Thiel.pdf
`Decision`	Solver.`makeSplitVariableDomain(IntVar var, long val, boolean start_with_lower_half)`
`Constraint`	Solver.`makeSubCircuit(IntVar[] nexts)`	Force the "nexts" variable to create a complete Hamiltonian path for those that do not loop upon themselves.
`IntExpr`	Solver.`makeSum(IntVar[] vars)`	sum of all vars.
`Constraint`	Solver.`makeSumEquality(IntVar[] vars, long cst)`
`Constraint`	Solver.`makeSumEquality(IntVar[] vars, IntVar var)`
`Constraint`	Solver.`makeSumGreaterOrEqual(IntVar[] vars, long cst)`
`Constraint`	Solver.`makeSumLessOrEqual(IntVar[] vars, long cst)`	Variation on arrays.
`IntVarLocalSearchFilter`	Solver.`makeSumObjectiveFilter(IntVar[] vars, IntVar[] secondary_vars, LongTernaryOperator values, int filter_enum)`
`IntVarLocalSearchFilter`	Solver.`makeSumObjectiveFilter(IntVar[] vars, java.util.function.LongBinaryOperator values, int filter_enum)`
`SearchMonitor`	Solver.`makeTabuSearch(boolean maximize, IntVar v, long step, IntVar[] vars, long keep_tenure, long forbid_tenure, double tabu_factor)`	MetaHeuristics which try to get the search out of local optima. Creates a Tabu Search monitor. In the context of local search the behavior is similar to MakeOptimize(), creating an objective in a given sense.
`Constraint`	Solver.`makeTemporalDisjunction(IntervalVar t1, IntervalVar t2, IntVar alt)`	This constraint implements a temporal disjunction between two interval vars t1 and t2.
`Constraint`	Solver.`makeTransitionConstraint(IntVar[] vars, IntTupleSet transition_table, long initial_state, int[] final_states)`	This constraint create a finite automaton that will check the sequence of variables vars.
`Constraint`	Solver.`makeTransitionConstraint(IntVar[] vars, IntTupleSet transition_table, long initial_state, long[] final_states)`	This constraint create a finite automaton that will check the sequence of variables vars.
`Decision`	Solver.`makeVariableGreaterOrEqualValue(IntVar var, long value)`
`Decision`	Solver.`makeVariableLessOrEqualValue(IntVar var, long value)`
`OptimizeVar`	Solver.`makeWeightedMaximize(IntVar[] sub_objectives, int[] weights, long step)`	Creates a maximization weigthed objective.
`OptimizeVar`	Solver.`makeWeightedMaximize(IntVar[] sub_objectives, long[] weights, long step)`	Creates a maximization weigthed objective.
`OptimizeVar`	Solver.`makeWeightedMinimize(IntVar[] sub_objectives, int[] weights, long step)`	Creates a minimization weighted objective.
`OptimizeVar`	Solver.`makeWeightedMinimize(IntVar[] sub_objectives, long[] weights, long step)`	Creates a minimization weighted objective.
`OptimizeVar`	Solver.`makeWeightedOptimize(boolean maximize, IntVar[] sub_objectives, int[] weights, long step)`	Creates a weighted objective with a given sense (true = maximization).
`OptimizeVar`	Solver.`makeWeightedOptimize(boolean maximize, IntVar[] sub_objectives, long[] weights, long step)`	Creates a weighted objective with a given sense (true = maximization).
`long`	Assignment.`max(IntVar var)`
`static long`	main.`maxVarArray(IntVar[] vars)`
`static long`	mainJNI.`maxVarArray(IntVar[] jarg1)`
`long`	Assignment.`min(IntVar var)`
`static long`	main.`minVarArray(IntVar[] vars)`
`static long`	mainJNI.`minVarArray(IntVar[] jarg1)`
`static long`	mainJNI.`ModelCache_findVarArrayConstantArrayExpression(long jarg1, ModelCache jarg1_, IntVar[] jarg2, long[] jarg3, int jarg4)`
`static long`	mainJNI.`ModelCache_findVarArrayConstantExpression(long jarg1, ModelCache jarg1_, IntVar[] jarg2, long jarg3, int jarg4)`
`static long`	mainJNI.`ModelCache_findVarArrayExpression(long jarg1, ModelCache jarg1_, IntVar[] jarg2, int jarg3)`
`static long`	mainJNI.`ModelCache_findVarConstantArrayExpression(long jarg1, ModelCache jarg1_, long jarg2, IntVar jarg2_, long[] jarg3, int jarg4)`
`static long`	mainJNI.`ModelCache_findVarConstantConstantConstraint(long jarg1, ModelCache jarg1_, long jarg2, IntVar jarg2_, long jarg3, long jarg4, int jarg5)`
`static long`	mainJNI.`ModelCache_findVarConstantConstantExpression(long jarg1, ModelCache jarg1_, long jarg2, IntVar jarg2_, long jarg3, long jarg4, int jarg5)`
`static long`	mainJNI.`ModelCache_findVarConstantConstraint(long jarg1, ModelCache jarg1_, long jarg2, IntVar jarg2_, long jarg3, int jarg4)`
`static void`	mainJNI.`ModelCache_insertVarArrayConstantArrayExpression(long jarg1, ModelCache jarg1_, long jarg2, IntExpr jarg2_, IntVar[] jarg3, long[] jarg4, int jarg5)`
`static void`	mainJNI.`ModelCache_insertVarArrayConstantExpression(long jarg1, ModelCache jarg1_, long jarg2, IntExpr jarg2_, IntVar[] jarg3, long jarg4, int jarg5)`
`static void`	mainJNI.`ModelCache_insertVarArrayExpression(long jarg1, ModelCache jarg1_, long jarg2, IntExpr jarg2_, IntVar[] jarg3, int jarg4)`
`static void`	mainJNI.`ModelCache_insertVarConstantArrayExpression(long jarg1, ModelCache jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntVar jarg3_, long[] jarg4, int jarg5)`
`static void`	mainJNI.`ModelCache_insertVarConstantConstantConstraint(long jarg1, ModelCache jarg1_, long jarg2, Constraint jarg2_, long jarg3, IntVar jarg3_, long jarg4, long jarg5, int jarg6)`
`static void`	mainJNI.`ModelCache_insertVarConstantConstantExpression(long jarg1, ModelCache jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntVar jarg3_, long jarg4, long jarg5, int jarg6)`
`static void`	mainJNI.`ModelCache_insertVarConstantConstraint(long jarg1, ModelCache jarg1_, long jarg2, Constraint jarg2_, long jarg3, IntVar jarg3_, long jarg4, int jarg5)`
`static void`	mainJNI.`ModelVisitor_visitIntegerVariable__SWIG_0(long jarg1, ModelVisitor jarg1_, long jarg2, IntVar jarg2_, long jarg3, IntExpr jarg3_)`
`static void`	mainJNI.`ModelVisitor_visitIntegerVariable__SWIG_1(long jarg1, ModelVisitor jarg1_, long jarg2, IntVar jarg2_, java.lang.String jarg3, long jarg4, long jarg5, IntVar jarg5_)`
`static void`	mainJNI.`ModelVisitor_visitIntegerVariableArrayArgument(long jarg1, ModelVisitor jarg1_, java.lang.String jarg2, IntVar[] jarg3)`
`IntVarElement`	AssignmentIntContainer.`mutableElement(IntVar var)`
`static long`	mainJNI.`new_BaseLns(IntVar[] jarg1)`
`static long`	mainJNI.`new_ChangeValue(IntVar[] jarg1)`
`static long`	mainJNI.`new_ImprovementSearchLimit(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, boolean jarg3, double jarg4, double jarg5, double jarg6, int jarg7)`
`static long`	mainJNI.`new_IntVarElement__SWIG_1(long jarg1, IntVar jarg1_)`
`static long`	mainJNI.`new_IntVarLocalSearchFilter(IntVar[] jarg1)`
`static long`	mainJNI.`new_IntVarLocalSearchOperator__SWIG_1(IntVar[] jarg1, boolean jarg2)`
`static long`	mainJNI.`new_IntVarLocalSearchOperator__SWIG_2(IntVar[] jarg1)`
`static long`	mainJNI.`new_OptimizeVar(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, long jarg4)`
`static long`	mainJNI.`new_Pack(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3)`
`static long`	mainJNI.`new_PathOperator(IntVar[] jarg1, IntVar[] jarg2, int jarg3, boolean jarg4, boolean jarg5, java.util.function.LongToIntFunction jarg6)`
`static long`	mainJNI.`new_SearchLog(long jarg1, Solver jarg1_, long jarg2, OptimizeVar jarg2_, long jarg3, IntVar jarg3_, double jarg4, double jarg5, java.util.function.Supplier<java.lang.String> jarg6, boolean jarg7, int jarg8)`
`static long`	mainJNI.`new_SequenceVar(long jarg1, Solver jarg1_, IntervalVar[] jarg2, IntVar[] jarg3, java.lang.String jarg4)`
`static long`	mainJNI.`new_Solver_IntegerCastInfo__SWIG_1(long jarg1, IntVar jarg1_, long jarg2, IntExpr jarg2_, long jarg3, Constraint jarg3_)`
`static void`	mainJNI.`Pack_addCountAssignedItemsDimension(long jarg1, Pack jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`Pack_addCountUsedBinDimension(long jarg1, Pack jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`Pack_addSumVariableWeightsLessOrEqualConstantDimension(long jarg1, Pack jarg1_, IntVar[] jarg2, long[] jarg3)`
`static void`	mainJNI.`Pack_addWeightedSumEqualVarDimension__SWIG_0(long jarg1, Pack jarg1_, long[] jarg2, IntVar[] jarg3)`
`static void`	mainJNI.`Pack_addWeightedSumEqualVarDimension__SWIG_1(long jarg1, Pack jarg1_, java.util.function.LongBinaryOperator jarg2, IntVar[] jarg3)`
`static void`	mainJNI.`Pack_addWeightedSumOfAssignedDimension(long jarg1, Pack jarg1_, long[] jarg2, long jarg3, IntVar jarg3_)`
`static void`	mainJNI.`PropagationBaseObject_set_variable_to_clean_on_fail(long jarg1, PropagationBaseObject jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`PropagationMonitor_endProcessingIntegerVariable(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`PropagationMonitor_removeInterval(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long jarg3, long jarg4)`
`static void`	mainJNI.`PropagationMonitor_removeValue(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`PropagationMonitor_removeValues(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long[] jarg3)`
`static void`	mainJNI.`PropagationMonitor_setMax__SWIG_1(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`PropagationMonitor_setMin__SWIG_1(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`PropagationMonitor_setRange__SWIG_1(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long jarg3, long jarg4)`
`static void`	mainJNI.`PropagationMonitor_setValue__SWIG_0(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`PropagationMonitor_setValue__SWIG_1(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_, long[] jarg3)`
`static void`	mainJNI.`PropagationMonitor_startProcessingIntegerVariable(long jarg1, PropagationMonitor jarg1_, long jarg2, IntVar jarg2_)`
`IntVar`	Solver.`registerIntVar(IntVar var)`	Registers a new IntVar and wraps it inside a TraceIntVar if necessary.
`void`	PropagationMonitor.`removeInterval(IntVar var, long imin, long imax)`
`void`	PropagationMonitor.`removeValue(IntVar var, long value)`
`void`	PropagationMonitor.`removeValues(IntVar var, long[] values)`
`void`	IntVarElement.`reset(IntVar var)`
`static void`	mainJNI.`RoutingModel_addToAssignment(long jarg1, RoutingModel jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`RoutingModel_addVariableMaximizedByFinalizer(long jarg1, RoutingModel jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`RoutingModel_addVariableMinimizedByFinalizer(long jarg1, RoutingModel jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`RoutingModel_addVariableTargetToFinalizer(long jarg1, RoutingModel jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`RoutingModel_AddWeightedVariableMinimizedByFinalizer(long jarg1, RoutingModel jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`RoutingModel_MakePathSpansAndTotalSlacks(long jarg1, RoutingModel jarg1_, long jarg2, RoutingDimension jarg2_, IntVar[] jarg3, IntVar[] jarg4)`
`void`	PropagationBaseObject.`set_variable_to_clean_on_fail(IntVar v)`	Shortcut for variable cleaner.
`static void`	main.`setAssignmentFromAssignment(Assignment target_assignment, IntVar[] target_vars, Assignment source_assignment, IntVar[] source_vars)`	NOLINT Given a "source_assignment", clears the "target_assignment" and adds all IntVars in "target_vars", with the values of the variables set according to the corresponding values of "source_vars" in "source_assignment". source_vars and target_vars must have the same number of elements. The source and target assignments can belong to different Solvers.
`static void`	mainJNI.`setAssignmentFromAssignment(long jarg1, Assignment jarg1_, IntVar[] jarg2, long jarg3, Assignment jarg3_, IntVar[] jarg4)`
`void`	Assignment.`setMax(IntVar var, long m)`
`void`	PropagationMonitor.`setMax(IntVar var, long new_max)`
`void`	Assignment.`setMin(IntVar var, long m)`
`void`	PropagationMonitor.`setMin(IntVar var, long new_min)`	IntVar modifiers.
`void`	Assignment.`setRange(IntVar var, long l, long u)`
`void`	PropagationMonitor.`setRange(IntVar var, long new_min, long new_max)`
`void`	Assignment.`setValue(IntVar var, long value)`
`void`	PropagationMonitor.`setValue(IntVar var, long value)`
`void`	PropagationMonitor.`setValue(IntVar var, long[] values)`
`void`	Solver.IntegerCastInfo.`setVariable(IntVar value)`
`static void`	mainJNI.`SolutionCollector_add__SWIG_0(long jarg1, SolutionCollector jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`SolutionCollector_add__SWIG_1(long jarg1, SolutionCollector jarg1_, IntVar[] jarg2)`
`static void`	mainJNI.`SolutionCollector_addObjective(long jarg1, SolutionCollector jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`SolutionCollector_value(long jarg1, SolutionCollector jarg1_, int jarg2, long jarg3, IntVar jarg3_)`
`static void`	mainJNI.`Solver_addCastConstraint(long jarg1, Solver jarg1_, long jarg2, CastConstraint jarg2_, long jarg3, IntVar jarg3_, long jarg4, IntExpr jarg4_)`
`static long`	mainJNI.`Solver_castExpression(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_)`
`static void`	mainJNI.`Solver_IntegerCastInfo_variable_set(long jarg1, Solver.IntegerCastInfo jarg1_, long jarg2, IntVar jarg2_)`
`static long`	mainJNI.`Solver_makeAbsEquality(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeAllDifferent__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2)`
`static long`	mainJNI.`Solver_makeAllDifferent__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, boolean jarg3)`
`static long`	mainJNI.`Solver_makeAllDifferentExcept(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3)`
`static long`	mainJNI.`Solver_makeAllowedAssignment(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntTupleSet jarg3_)`
`static long`	mainJNI.`Solver_makeAssignVariablesValues(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3)`
`static long`	mainJNI.`Solver_makeAssignVariableValue(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Solver_MakeAssignVariableValueOrDoNothing(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Solver_makeAssignVariableValueOrFail(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Solver_makeCircuit(long jarg1, Solver jarg1_, IntVar[] jarg2)`
`static long`	mainJNI.`Solver_makeConditionalExpression(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, IntExpr jarg3_, long jarg4)`
`static long`	mainJNI.`Solver_makeCount__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeCount__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeCumulative__SWIG_2(long jarg1, Solver jarg1_, IntervalVar[] jarg2, long[] jarg3, long jarg4, IntVar jarg4_, java.lang.String jarg5)`
`static long`	mainJNI.`Solver_makeCumulative__SWIG_3(long jarg1, Solver jarg1_, IntervalVar[] jarg2, int[] jarg3, long jarg4, IntVar jarg4_, java.lang.String jarg5)`
`static long`	mainJNI.`Solver_makeCumulative__SWIG_4(long jarg1, Solver jarg1_, IntervalVar[] jarg2, IntVar[] jarg3, long jarg4, java.lang.String jarg5)`
`static long`	mainJNI.`Solver_makeCumulative__SWIG_5(long jarg1, Solver jarg1_, IntervalVar[] jarg2, IntVar[] jarg3, long jarg4, IntVar jarg4_, java.lang.String jarg5)`
`static long`	mainJNI.`Solver_makeDecisionBuilderFromAssignment(long jarg1, Solver jarg1_, long jarg2, Assignment jarg2_, long jarg3, DecisionBuilder jarg3_, IntVar[] jarg4)`
`static long`	mainJNI.`Solver_makeDefaultPhase__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2)`
`static long`	mainJNI.`Solver_makeDefaultPhase__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, DefaultPhaseParameters jarg3_)`
`static long`	mainJNI.`Solver_makeDelayedPathCumul(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5)`
`static long`	mainJNI.`Solver_makeDeviation(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_, long jarg4)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, IntVar[] jarg4)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, IntVar[] jarg4)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_3(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, long jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_4(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long[] jarg4)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_5(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, int[] jarg4)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_6(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long[] jarg4, long[] jarg5)`
`static long`	mainJNI.`Solver_makeDistribute__SWIG_7(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, int[] jarg4, int[] jarg5)`
`static long`	mainJNI.`Solver_makeElement__SWIG_0(long jarg1, Solver jarg1_, long[] jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeElement__SWIG_1(long jarg1, Solver jarg1_, int[] jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeElement__SWIG_2(long jarg1, Solver jarg1_, java.util.function.LongUnaryOperator jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeElement__SWIG_3(long jarg1, Solver jarg1_, java.util.function.LongBinaryOperator jarg2, long jarg3, IntVar jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeElement__SWIG_4(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeElementEquality__SWIG_0(long jarg1, Solver jarg1_, long[] jarg2, long jarg3, IntVar jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeElementEquality__SWIG_1(long jarg1, Solver jarg1_, int[] jarg2, long jarg3, IntVar jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeElementEquality__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeElementEquality__SWIG_3(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_, long jarg4)`
`static long`	mainJNI.`Solver_makeFixedDurationIntervalVar__SWIG_1(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, java.lang.String jarg4)`
`static long`	mainJNI.`Solver_makeFixedDurationIntervalVar__SWIG_2(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, long jarg4, IntVar jarg4_, java.lang.String jarg5)`
`static long`	mainJNI.`Solver_makeGenericTabuSearch(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, long jarg4, IntVar[] jarg5, long jarg6)`
`static long`	mainJNI.`Solver_makeGuidedLocalSearch__SWIG_0(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, java.util.function.LongBinaryOperator jarg4, long jarg5, IntVar[] jarg6, double jarg7)`
`static long`	mainJNI.`Solver_makeGuidedLocalSearch__SWIG_1(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, LongTernaryOperator jarg4, long jarg5, IntVar[] jarg6, IntVar[] jarg7, double jarg8)`
`static long`	mainJNI.`Solver_makeIfThenElseCt(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntExpr jarg4_, long jarg5, IntVar jarg5_)`
`static long`	mainJNI.`Solver_MakeImprovementLimit(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, boolean jarg3, double jarg4, double jarg5, double jarg6, int jarg7)`
`static long`	mainJNI.`Solver_makeIndexExpression(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3)`
`static long`	mainJNI.`Solver_makeIndexOfConstraint(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_, long jarg4)`
`static long`	mainJNI.`Solver_makeIndexOfFirstMaxValueConstraint(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeIndexOfFirstMinValueConstraint(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeInversePermutationConstraint(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeIsBetweenCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, long jarg4, long jarg5, IntVar jarg5_)`
`static long`	mainJNI.`Solver_makeIsDifferentCstCt__SWIG_0(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsDifferentCstCt__SWIG_1(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsEqualCstCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsEqualVar__SWIG_0(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsGreaterCstCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsGreaterCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsGreaterOrEqualCstCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsGreaterOrEqualCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsLessCstCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsLessCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsLessOrEqualCstCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsLessOrEqualCt(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long jarg3, IntExpr jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsMemberCt__SWIG_0(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, long[] jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeIsMemberCt__SWIG_1(long jarg1, Solver jarg1_, long jarg2, IntExpr jarg2_, int[] jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeLexicalLess(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeLexicalLessOrEqual(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeLocalSearchPhase__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, DecisionBuilder jarg3_, long jarg4, LocalSearchPhaseParameters jarg4_)`
`static long`	mainJNI.`Solver_makeLocalSearchPhase__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, DecisionBuilder jarg3_, long jarg4, DecisionBuilder jarg4_, long jarg5, LocalSearchPhaseParameters jarg5_)`
`static long`	mainJNI.`Solver_makeLocalSearchPhaseParameters__SWIG_0(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, LocalSearchOperator jarg3_, long jarg4, DecisionBuilder jarg4_)`
`static long`	mainJNI.`Solver_makeLocalSearchPhaseParameters__SWIG_1(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, LocalSearchOperator jarg3_, long jarg4, DecisionBuilder jarg4_, long jarg5, RegularLimit jarg5_)`
`static long`	mainJNI.`Solver_makeLocalSearchPhaseParameters__SWIG_2(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, LocalSearchOperator jarg3_, long jarg4, DecisionBuilder jarg4_, long jarg5, RegularLimit jarg5_, long jarg6, LocalSearchFilterManager jarg6_)`
`static long`	mainJNI.`Solver_makeLocalSearchPhaseParameters__SWIG_3(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, SolutionPool jarg3_, long jarg4, LocalSearchOperator jarg4_, long jarg5, DecisionBuilder jarg5_)`
`static long`	mainJNI.`Solver_makeLocalSearchPhaseParameters__SWIG_4(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, SolutionPool jarg3_, long jarg4, LocalSearchOperator jarg4_, long jarg5, DecisionBuilder jarg5_, long jarg6, RegularLimit jarg6_)`
`static long`	mainJNI.`Solver_makeLocalSearchPhaseParameters__SWIG_5(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, SolutionPool jarg3_, long jarg4, LocalSearchOperator jarg4_, long jarg5, DecisionBuilder jarg5_, long jarg6, RegularLimit jarg6_, long jarg7, LocalSearchFilterManager jarg7_)`
`static long`	mainJNI.`Solver_makeMapDomain(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeMax__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2)`
`static long`	mainJNI.`Solver_makeMaxEquality(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeMaximize(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Solver_makeMin__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2)`
`static long`	mainJNI.`Solver_makeMinEquality(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeMinimize(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Solver_makeMonotonicElement(long jarg1, Solver jarg1_, java.util.function.LongUnaryOperator jarg2, boolean jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeMoveTowardTargetOperator__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3)`
`static long`	mainJNI.`Solver_makeNoCycle__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, java.util.function.LongPredicate jarg4)`
`static long`	mainJNI.`Solver_makeNoCycle__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeNoCycle__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, java.util.function.LongPredicate jarg4, boolean jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingBoxesConstraint__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingBoxesConstraint__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long[] jarg4, long[] jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingBoxesConstraint__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int[] jarg4, int[] jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingNonStrictBoxesConstraint__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingNonStrictBoxesConstraint__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long[] jarg4, long[] jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingNonStrictBoxesConstraint__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int[] jarg4, int[] jarg5)`
`static long`	mainJNI.`Solver_makeNullIntersect(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeNullIntersectExcept(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, LongTernaryOperator jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_3(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, LongTernaryOperator jarg4, int jarg5)`
`static long`	mainJNI.`Solver_makeOptimize(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, long jarg4)`
`static long`	mainJNI.`Solver_makePack(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3)`
`static long`	mainJNI.`Solver_makePathConnected(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long[] jarg4, IntVar[] jarg5)`
`static long`	mainJNI.`Solver_makePathCumul__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5)`
`static long`	mainJNI.`Solver_makePathCumul__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, java.util.function.LongBinaryOperator jarg5)`
`static long`	mainJNI.`Solver_makePathCumul__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5, java.util.function.LongBinaryOperator jarg6)`
`static long`	mainJNI.`Solver_makePhase__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makePhase__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, java.util.function.LongUnaryOperator jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makePhase__SWIG_10(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, IntVar jarg3_, long jarg4, IntVar jarg4_, long jarg5, IntVar jarg5_, int jarg6, int jarg7)`
`static long`	mainJNI.`Solver_makePhase__SWIG_11(long jarg1, Solver jarg1_, IntVar[] jarg2, java.util.function.LongBinaryOperator jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makePhase__SWIG_12(long jarg1, Solver jarg1_, IntVar[] jarg2, java.util.function.LongBinaryOperator jarg3, java.util.function.LongUnaryOperator jarg4, int jarg5)`
`static long`	mainJNI.`Solver_makePhase__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3, java.util.function.LongBinaryOperator jarg4)`
`static long`	mainJNI.`Solver_makePhase__SWIG_3(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3, LongTernaryPredicate jarg4)`
`static long`	mainJNI.`Solver_makePhase__SWIG_4(long jarg1, Solver jarg1_, IntVar[] jarg2, java.util.function.LongUnaryOperator jarg3, java.util.function.LongBinaryOperator jarg4)`
`static long`	mainJNI.`Solver_makePhase__SWIG_5(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3, java.util.function.LongBinaryOperator jarg4, java.util.function.LongUnaryOperator jarg5)`
`static long`	mainJNI.`Solver_makePhase__SWIG_6(long jarg1, Solver jarg1_, IntVar[] jarg2, java.util.function.LongUnaryOperator jarg3, java.util.function.LongBinaryOperator jarg4, java.util.function.LongUnaryOperator jarg5)`
`static long`	mainJNI.`Solver_makePhase__SWIG_7(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, int jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makePhase__SWIG_8(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, IntVar jarg3_, int jarg4, int jarg5)`
`static long`	mainJNI.`Solver_makePhase__SWIG_9(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, IntVar jarg3_, long jarg4, IntVar jarg4_, int jarg5, int jarg6)`
`static long`	mainJNI.`Solver_makeRandomLnsOperator__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3)`
`static long`	mainJNI.`Solver_makeRandomLnsOperator__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makeScalProd__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3)`
`static long`	mainJNI.`Solver_makeScalProd__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3)`
`static long`	mainJNI.`Solver_makeScalProdEquality__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeScalProdEquality__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeScalProdEquality__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeScalProdEquality__SWIG_3(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeScalProdGreaterOrEqual__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeScalProdGreaterOrEqual__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeScalProdLessOrEqual__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeScalProdLessOrEqual__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeSearchLog__SWIG_1(long jarg1, Solver jarg1_, int jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeSearchLog__SWIG_3(long jarg1, Solver jarg1_, int jarg2, long jarg3, IntVar jarg3_, java.util.function.Supplier<java.lang.String> jarg4)`
`static long`	mainJNI.`Solver_makeSimulatedAnnealing(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, long jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeSortingConstraint(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_makeSplitVariableDomain(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3, boolean jarg4)`
`static long`	mainJNI.`Solver_makeSubCircuit(long jarg1, Solver jarg1_, IntVar[] jarg2)`
`static long`	mainJNI.`Solver_makeSum__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2)`
`static long`	mainJNI.`Solver_makeSumEquality__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3)`
`static long`	mainJNI.`Solver_makeSumEquality__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntVar jarg3_)`
`static long`	mainJNI.`Solver_makeSumGreaterOrEqual(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3)`
`static long`	mainJNI.`Solver_makeSumLessOrEqual(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3)`
`static long`	mainJNI.`Solver_makeSumObjectiveFilter__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, java.util.function.LongBinaryOperator jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makeSumObjectiveFilter__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, LongTernaryOperator jarg4, int jarg5)`
`static long`	mainJNI.`Solver_makeTabuSearch(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, long jarg4, IntVar[] jarg5, long jarg6, long jarg7, double jarg8)`
`static long`	mainJNI.`Solver_makeTemporalDisjunction__SWIG_0(long jarg1, Solver jarg1_, long jarg2, IntervalVar jarg2_, long jarg3, IntervalVar jarg3_, long jarg4, IntVar jarg4_)`
`static long`	mainJNI.`Solver_makeTransitionConstraint__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntTupleSet jarg3_, long jarg4, long[] jarg5)`
`static long`	mainJNI.`Solver_makeTransitionConstraint__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, IntTupleSet jarg3_, long jarg4, int[] jarg5)`
`static long`	mainJNI.`Solver_makeVariableGreaterOrEqualValue(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Solver_makeVariableLessOrEqualValue(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static long`	mainJNI.`Solver_makeWeightedMaximize__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeWeightedMaximize__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeWeightedMinimize__SWIG_0(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeWeightedMinimize__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int[] jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeWeightedOptimize__SWIG_0(long jarg1, Solver jarg1_, boolean jarg2, IntVar[] jarg3, long[] jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeWeightedOptimize__SWIG_1(long jarg1, Solver jarg1_, boolean jarg2, IntVar[] jarg3, int[] jarg4, long jarg5)`
`static long`	mainJNI.`Solver_registerIntVar(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_)`
`void`	PropagationMonitor.`startProcessingIntegerVariable(IntVar var)`
`static void`	mainJNI.`SymmetryBreaker_addIntegerVariableEqualValueClause(long jarg1, SymmetryBreaker jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`SymmetryBreaker_addIntegerVariableGreaterOrEqualValueClause(long jarg1, SymmetryBreaker jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`static void`	mainJNI.`SymmetryBreaker_addIntegerVariableLessOrEqualValueClause(long jarg1, SymmetryBreaker jarg1_, long jarg2, IntVar jarg2_, long jarg3)`
`long`	Assignment.`value(IntVar var)`
`long`	SolutionCollector.`value(int n, IntVar var)`	This is a shortcut to get the Value of 'var' in the nth solution.
`boolean`	IntVarLocalSearchHandler.`ValueFromAssignment(Assignment assignment, IntVar var, long index, int[] value)`
`void`	ModelVisitor.`visitIntegerVariable(IntVar variable, IntExpr delegate)`
`void`	ModelVisitor.`visitIntegerVariable(IntVar variable, java.lang.String operation, long value, IntVar delegate)`
`void`	ModelVisitor.`visitIntegerVariableArrayArgument(java.lang.String arg_name, IntVar[] arguments)`
`void`	DecisionVisitor.`visitSetVariableValue(IntVar var, long value)`
`void`	DecisionVisitor.`visitSplitVariableDomain(IntVar var, long value, boolean start_with_lower_half)`

Constructors in com.google.ortools.constraintsolver with parameters of type IntVar
Constructor	Description
`BaseLns(IntVar[] vars)`
`ChangeValue(IntVar[] vars)`
`ImprovementSearchLimit(Solver s, IntVar objective_var, boolean maximize, double objective_scaling_factor, double objective_offset, double improvement_rate_coefficient, int improvement_rate_solutions_distance)`
`IntegerCastInfo(IntVar v, IntExpr e, Constraint c)`
`IntVarElement(IntVar var)`
`IntVarLocalSearchFilter(IntVar[] vars)`
`IntVarLocalSearchOperator(IntVar[] vars)`
`IntVarLocalSearchOperator(IntVar[] vars, boolean keep_inverse_values)`
`OptimizeVar(Solver s, boolean maximize, IntVar a, long step)`
`Pack(Solver s, IntVar[] vars, int number_of_bins)`
`PathOperator(IntVar[] next_vars, IntVar[] path_vars, int number_of_base_nodes, boolean skip_locally_optimal_paths, boolean accept_path_end_base, java.util.function.LongToIntFunction start_empty_path_class)`	Builds an instance of PathOperator from next and path variables. 'number_of_base_nodes' is the number of nodes needed to define a neighbor.
`SearchLog(Solver s, OptimizeVar obj, IntVar var, double scaling_factor, double offset, java.util.function.Supplier<java.lang.String> display_callback, boolean display_on_new_solutions_only, int period)`
`SequenceVar(Solver s, IntervalVar[] intervals, IntVar[] nexts, java.lang.String name)`

Uses of Classcom.google.ortools.constraintsolver.IntVar

Uses of IntVar in com.google.ortools.constraintsolver

Uses of Class
com.google.ortools.constraintsolver.IntVar