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

Packages that use IntVar
Package Description

com.google.ortools.constraintsolver

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 and Description
`class`	`BooleanVar`

Methods in com.google.ortools.constraintsolver that return IntVar
Modifier and Type	Method and 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 v1, IntExpr v2)` status var of (v1 !
`IntVar`	Solver.`makeIsDifferentCstVar(IntExpr var, long value)` status var of (var !
`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`	ObjectiveMonitor.`MinimizationVar(int index)`
`IntVar`	BaseObjectiveMonitor.`MinimizationVar(int index)`
`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`	Assignment.`ObjectiveFromIndex(int index)`
`IntVar`	ObjectiveMonitor.`ObjectiveVar(int index)`
`IntVar`	BaseObjectiveMonitor.`ObjectiveVar(int index)`
`IntVar`	Solver.`registerIntVar(IntVar var)` Registers a new IntVar and wraps it inside a TraceIntVar if necessary.
`IntVar`	RoutingModel.`ResourceVar(int vehicle, int resource_group)` Returns the resource variable for the given vehicle index in the given resource group.
`IntVar[]`	RoutingModel.`ResourceVars(int resource_group)` Returns vehicle resource variables for a given resource group, such that ResourceVars(r_g)[v] is the resource variable for vehicle 'v' in resource group 'r_g'.
`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_ResourceVars(long jarg1, RoutingModel jarg1_, int jarg2)`
`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`	IntVarElement.`var()`
`IntVar`	Constraint.`var()` Creates a Boolean variable representing the status of the constraint (false = constraint is violated, true = constraint is satisfied).
`IntVar`	IntVar.`var()`
`IntVar`	BaseIntExpr.`var()`
`IntVar`	OptimizeVar.`var()` Returns the variable that is optimized.
`IntVar`	IntExpr.`var()` Creates a variable from the expression.
`IntVar`	IntVarLocalSearchFilter.`var(int index)`
`IntVar`	IntVarLocalSearchOperator.`var(long index)` Returns the variable of given index.
`IntVar`	IntExpr.`varWithName(java.lang.String name)` Creates a variable from the expression and set the name of the resulting var.
`IntVar`	RoutingModel.`VehicleRouteConsideredVar(int vehicle)` Returns the variable specifying whether or not the given vehicle route is considered for costs and constraints.
`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 and Description
`void`	Assignment.`activate(IntVar var)`
`boolean`	Assignment.`activated(IntVar var)`
`void`	SolutionCollector.`add(IntVar var)` Add API.
`IntVarElement`	AssignmentIntContainer.`add(IntVar var)`
`IntVarElement`	Assignment.`add(IntVar var)`
`void`	SolutionCollector.`add(IntVar[] vars)`
`void`	Assignment.`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`	SolutionCollector.`addObjective(IntVar objective)`
`void`	Assignment.`addObjective(IntVar v)`
`void`	SolutionCollector.`AddObjectives(IntVar[] objectives)`
`void`	Assignment.`AddObjectives(IntVar[] vars)`
`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.
`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`	IntVarLocalSearchOperator.`addVars(IntVar[] vars)`
`void`	IntVarLocalSearchFilter.`addVars(IntVar[] vars)` Add variables to "track" to the filter.
`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.`AddWeightedVariableMaximizedByFinalizer(IntVar var, long cost)` Adds a variable to maximize in the solution finalizer, with a weighted priority: the higher the more priority it has.
`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.
`void`	RoutingModel.`AddWeightedVariableTargetToFinalizer(IntVar var, long target, long cost)` Same as above with a weighted priority: the higher the cost, the more priority it has to be set close to the target value.
`static boolean`	mainJNI.`areAllBooleans(IntVar[] jarg1)`
`static boolean`	main.`areAllBooleans(IntVar[] vars)`
`static boolean`	mainJNI.`areAllBound(IntVar[] jarg1)`
`static boolean`	main.`areAllBound(IntVar[] vars)`
`static boolean`	mainJNI.`areAllBoundTo(IntVar[] jarg1, long jarg2)`
`static boolean`	main.`areAllBoundTo(IntVar[] vars, long value)` Returns true if all variables are assigned to 'value'.
`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 void`	mainJNI.`Assignment_AddObjectives(long jarg1, Assignment jarg1_, 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`	AssignmentIntContainer.`contains(IntVar var)`
`boolean`	Assignment.`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`	AssignmentIntContainer.`fastAdd(IntVar var)` Adds element without checking its presence in the container.
`IntVarElement`	Assignment.`fastAdd(IntVar var)` Adds without checking if variable has been previously added.
`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.
`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.`IntVarLocalSearchOperator_addVars(long jarg1, IntVarLocalSearchOperator 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.`MakeAssignVariablesValuesOrDoNothing(IntVar[] vars, long[] values)`
`Decision`	Solver.`MakeAssignVariablesValuesOrFail(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 ?
`Constraint`	Solver.`makeCount(IntVar[] vars, long value, IntVar 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.`makeCount(IntVar[] vars, long value, long 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.
`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.
`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.
`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.
`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.
`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.`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.`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.`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.`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 .. card_size - 1: card_min[j] <= \|{i \| v[i] == j}\| <= card_max[j]
`Constraint`	Solver.`makeDistribute(IntVar[] vars, int[] values, int[] card_min, int[] card_max)` Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= \|{i \| v[i] == values[j]}\| <= card_max[j]
`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, int[] values, IntVar[] cards)` Aggregated version of count: \|{i \| v[i] == values[j]}\| == cards[j]
`Constraint`	Solver.`makeDistribute(IntVar[] vars, IntVar[] cards)` Aggregated version of count: \|{i \| v[i] == j}\| == cards[j]
`Constraint`	Solver.`makeDistribute(IntVar[] vars, IntVar[] cards)` Aggregated version of count: \|{i \| v[i] == j}\| == cards[j]
`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[] 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 .. card_size - 1: card_min[j] <= \|{i \| v[i] == j}\| <= card_max[j]
`Constraint`	Solver.`makeDistribute(IntVar[] vars, long[] values, long[] card_min, long[] card_max)` Aggregated version of count with bounded cardinalities: forall j in 0 .. card_size - 1: card_min[j] <= \|{i \| v[i] == values[j]}\| <= card_max[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 .. card_size - 1: card_min <= \|{i \| v[i] == j}\| <= card_max
`IntExpr`	Solver.`makeElement(int[] values, IntVar index)` values[index]
`IntExpr`	Solver.`makeElement(IntVar[] vars, IntVar index)` vars[expr]
`IntExpr`	Solver.`makeElement(IntVar[] vars, IntVar index)` vars[expr]
`IntExpr`	Solver.`makeElement(long[] values, IntVar index)` values[index]
`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(IntVar[] vars, IntVar index, IntVar target)`
`Constraint`	Solver.`makeElementEquality(IntVar[] vars, IntVar index, IntVar target)`
`Constraint`	Solver.`makeElementEquality(IntVar[] vars, IntVar index, long target)`
`Constraint`	Solver.`makeElementEquality(IntVar[] vars, IntVar index, long target)`
`Constraint`	Solver.`makeElementEquality(long[] vals, 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.
`IntervalVar`	Solver.`makeFixedDurationIntervalVar(IntVar start_variable, long duration, java.lang.String name)` Creates a performed interval var with a fixed duration.
`ObjectiveMonitor`	Solver.`makeGenericTabuSearch(boolean maximize, IntVar v, long step, IntVar[] tabu_vars, long forbid_tenure)` Creates a Tabu Search based on the vars \|vars\|.
`ObjectiveMonitor`	Solver.`makeGenericTabuSearch(boolean maximize, IntVar v, long step, IntVar[] tabu_vars, long forbid_tenure)` Creates a Tabu Search based on the vars \|vars\|.
`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.
`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.`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.`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.`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. for all i in [0..left.size()-1], right[left[i]] = i.
`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. for all i in [0..left.size()-1], right[left[i]] = i.
`Constraint`	Solver.`makeIsBetweenCt(IntExpr expr, long l, long u, IntVar b)` b == (l <= expr <= u)
`Constraint`	Solver.`makeIsDifferentCstCt(IntExpr v1, IntExpr v2, IntVar b)` b == (v1 !
`Constraint`	Solver.`makeIsDifferentCstCt(IntExpr var, long value, IntVar boolvar)` boolvar == (var !
`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.`MakeIsLexicalLessOrEqualWithOffsetsCt(IntVar[] left, IntVar[] right, long[] offsets, IntVar boolvar)`
`Constraint`	Solver.`MakeIsLexicalLessOrEqualWithOffsetsCt(IntVar[] left, IntVar[] right, long[] offsets, IntVar boolvar)`
`Constraint`	Solver.`MakeIsLexicalLessOrEqualWithOffsetsCt(IntVar[] left, IntVar[] right, long[] offsets, IntVar boolvar)`
`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.`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.
`Constraint`	Solver.`makeLexicalLessOrEqual(IntVar[] left, IntVar[] right)` Creates a constraint that enforces that left is lexicographically less than or equal to right.
`Constraint`	Solver.`MakeLexicalLessOrEqualWithOffsets(IntVar[] left, IntVar[] right, long[] offsets)` Creates a constraint that enforces that left is lexicographically less than or equal to right with an offset.
`Constraint`	Solver.`MakeLexicalLessOrEqualWithOffsets(IntVar[] left, IntVar[] right, long[] offsets)` Creates a constraint that enforces that left is lexicographically less than or equal to right with an offset.
`ImprovementSearchLimit`	Solver.`MakeLexicographicImprovementLimit(IntVar[] objective_vars, SWIGTYPE_p_std__vectorT_bool_t maximize, double[] objective_scaling_factors, double[] objective_offsets, double improvement_rate_coefficient, int improvement_rate_solutions_distance)` Same as MakeImprovementLimit on a lexicographic objective based on 'objective_vars' and related arguments.
`OptimizeVar`	Solver.`MakeLexicographicOptimize(SWIGTYPE_p_std__vectorT_bool_t maximize, IntVar[] variables, long[] steps)` Creates a lexicographic objective, following the order of the variables given.
`ObjectiveMonitor`	Solver.`MakeLexicographicSimulatedAnnealing(SWIGTYPE_p_std__vectorT_bool_t maximize, IntVar[] vars, long[] steps, long[] initial_temperatures)`
`ObjectiveMonitor`	Solver.`MakeLexicographicTabuSearch(SWIGTYPE_p_std__vectorT_bool_t maximize, IntVar[] objectives, long[] steps, IntVar[] vars, long keep_tenure, long forbid_tenure, double tabu_factor)`
`ObjectiveMonitor`	Solver.`MakeLexicographicTabuSearch(SWIGTYPE_p_std__vectorT_bool_t maximize, IntVar[] objectives, long[] steps, IntVar[] vars, long keep_tenure, long forbid_tenure, double tabu_factor)`
`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'.
`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)`
`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)`
`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)` 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)` Prevent cycles.
`Constraint`	Solver.`makeNoCycle(IntVar[] nexts, IntVar[] active, java.util.function.LongPredicate sink_handler, boolean assume_paths)`
`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, IntVar[] x_size, IntVar[] y_size)` This constraint states that all the boxes must not overlap.
`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.
`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.
`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.
`Constraint`	Solver.`makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size)`
`Constraint`	Solver.`makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size)`
`Constraint`	Solver.`makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t y_size)`
`Constraint`	Solver.`makeNonOverlappingBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t 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.
`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.
`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.
`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.
`Constraint`	Solver.`makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size)`
`Constraint`	Solver.`makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_int_const_t x_size, SWIGTYPE_p_absl__SpanT_int_const_t y_size)`
`Constraint`	Solver.`makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t y_size)`
`Constraint`	Solver.`makeNonOverlappingNonStrictBoxesConstraint(IntVar[] x_vars, IntVar[] y_vars, SWIGTYPE_p_absl__SpanT_long_const_t x_size, SWIGTYPE_p_absl__SpanT_long_const_t y_size)`
`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.`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.
`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, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors)` Local Search Operators.
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_outgoing_neighbors)` Local Search Operators.
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, int op)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, int op)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_outgoing_neighbors)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, int op, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_incoming_neighbors, SWIGTYPE_p_std__functionT_std__vectorT_int_t_const_Rfint_intF_t get_outgoing_neighbors)`
`LocalSearchOperator`	Solver.`makeOperator(IntVar[] vars, IntVar[] secondary_vars, LongTernaryOperator evaluator, 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].
`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].
`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].
`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].
`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].
`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].
`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].
`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].
`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].
`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].
`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]).
`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]).
`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]).
`DecisionBuilder`	Solver.`makePhase(IntVar[] vars, int var_str, int val_str)` Phases on IntVar arrays.
`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, 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, 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, IntVar target)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, int[] coefficients, IntVar target)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, int[] coefficients, long cst)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, long[] coefficients, IntVar target)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, long[] coefficients, IntVar target)`
`Constraint`	Solver.`makeScalProdEquality(IntVar[] vars, long[] coefficients, long cst)`
`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[] vars, java.util.function.Supplier<java.lang.String> display_callback)` At each solution, this monitor will display the 'vars' values and the result of `display_callback`.
`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`.
`ObjectiveMonitor`	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.
`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.
`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, IntVar var)`
`Constraint`	Solver.`makeSumEquality(IntVar[] vars, IntVar var)`
`Constraint`	Solver.`makeSumEquality(IntVar[] vars, long cst)`
`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, IntVar[] secondary_vars, LongTernaryOperator values, int filter_enum)`
`IntVarLocalSearchFilter`	Solver.`makeSumObjectiveFilter(IntVar[] vars, java.util.function.LongBinaryOperator values, int filter_enum)`
`ObjectiveMonitor`	Solver.`makeTabuSearch(boolean maximize, IntVar objective, long step, IntVar[] vars, long keep_tenure, long forbid_tenure, double tabu_factor)` MetaHeuristics which try to get the search out of local optima.
`ObjectiveMonitor`	Solver.`makeTabuSearch(boolean maximize, IntVar objective, long step, IntVar[] vars, long keep_tenure, long forbid_tenure, double tabu_factor)` MetaHeuristics which try to get the search out of local optima.
`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`	mainJNI.`maxVarArray(IntVar[] jarg1)`
`static long`	main.`maxVarArray(IntVar[] vars)`
`long`	Assignment.`min(IntVar var)`
`static long`	mainJNI.`minVarArray(IntVar[] jarg1)`
`static long`	main.`minVarArray(IntVar[] vars)`
`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__SWIG_0(long jarg1, Solver jarg1_, long jarg2, IntVar jarg2_, boolean jarg3, double jarg4, double jarg5, double jarg6, int jarg7)`
`static long`	mainJNI.`new_ImprovementSearchLimit__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, long 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_0(IntVar[] jarg1, boolean jarg2)`
`static long`	mainJNI.`new_IntVarLocalSearchOperator__SWIG_1(IntVar[] jarg1)`
`static long`	mainJNI.`new_ObjectiveMonitor(long jarg1, Solver jarg1_, long jarg2, IntVar[] jarg3, long[] jarg4)`
`static long`	mainJNI.`new_OptimizeVar__SWIG_0(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, long jarg4)`
`static long`	mainJNI.`new_OptimizeVar__SWIG_1(long jarg1, Solver jarg1_, long jarg2, IntVar[] jarg3, long[] jarg4)`
`static long`	mainJNI.`new_Pack(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3)`
`static long`	mainJNI.`new_SearchLog(long jarg1, Solver jarg1_, IntVar[] jarg2, java.lang.String 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_AddWeightedVariableMaximizedByFinalizer(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 void`	mainJNI.`RoutingModel_AddWeightedVariableTargetToFinalizer(long jarg1, RoutingModel jarg1_, long jarg2, IntVar jarg2_, long jarg3, long 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".
`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".
`static void`	mainJNI.`setAssignmentFromAssignment(long jarg1, Assignment jarg1_, IntVar[] jarg2, long jarg3, Assignment jarg3_, IntVar[] jarg4)`
`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 void`	mainJNI.`SolutionCollector_AddObjectives(long jarg1, SolutionCollector jarg1_, 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_MakeAssignVariablesValuesOrDoNothing(long jarg1, Solver jarg1_, IntVar[] jarg2, long[] jarg3)`
`static long`	mainJNI.`Solver_MakeAssignVariablesValuesOrFail(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_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_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_makeDelayedPathCumul(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5)`
`static long`	mainJNI.`Solver_makeDelayedPathCumul(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5)`
`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_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_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_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_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_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_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_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_makeGenericTabuSearch(long jarg1, Solver jarg1_, boolean jarg2, long jarg3, IntVar jarg3_, long jarg4, IntVar[] jarg5, long jarg6)`
`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_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_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_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_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_MakeIsLexicalLessOrEqualWithOffsetsCt(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long[] jarg4, long jarg5, IntVar jarg5_)`
`static long`	mainJNI.`Solver_MakeIsLexicalLessOrEqualWithOffsetsCt(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long[] jarg4, long jarg5, IntVar jarg5_)`
`static long`	mainJNI.`Solver_MakeIsLexicalLessOrEqualWithOffsetsCt(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long[] jarg4, long jarg5, IntVar jarg5_)`
`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_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_makeLexicalLessOrEqual(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`static long`	mainJNI.`Solver_MakeLexicalLessOrEqualWithOffsets(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long[] jarg4)`
`static long`	mainJNI.`Solver_MakeLexicalLessOrEqualWithOffsets(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long[] jarg4)`
`static long`	mainJNI.`Solver_MakeLexicographicImprovementLimit(long jarg1, Solver jarg1_, IntVar[] jarg2, long jarg3, double[] jarg4, double[] jarg5, double jarg6, int jarg7)`
`static long`	mainJNI.`Solver_MakeLexicographicOptimize(long jarg1, Solver jarg1_, long jarg2, IntVar[] jarg3, long[] jarg4)`
`static long`	mainJNI.`Solver_MakeLexicographicSimulatedAnnealing(long jarg1, Solver jarg1_, long jarg2, IntVar[] jarg3, long[] jarg4, long[] jarg5)`
`static long`	mainJNI.`Solver_MakeLexicographicTabuSearch(long jarg1, Solver jarg1_, long jarg2, IntVar[] jarg3, long[] jarg4, IntVar[] jarg5, long jarg6, long jarg7, double jarg8)`
`static long`	mainJNI.`Solver_MakeLexicographicTabuSearch(long jarg1, Solver jarg1_, long jarg2, IntVar[] jarg3, long[] jarg4, IntVar[] jarg5, long jarg6, long jarg7, double jarg8)`
`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_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_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_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_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_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_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_0(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] 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_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_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, long jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingBoxesConstraint__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long jarg4, long 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_0(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] 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_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_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, long jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeNonOverlappingNonStrictBoxesConstraint__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, long jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeNullIntersect(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3)`
`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_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, long jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_1(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3, long jarg4)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, int jarg3)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_3(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int jarg4, long jarg5, long jarg6)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_3(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int jarg4, long jarg5, long jarg6)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_4(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_4(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int jarg4, long jarg5)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_5(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_5(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_6(long jarg1, Solver jarg1_, IntVar[] jarg2, LongTernaryOperator jarg3, int jarg4)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_7(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, LongTernaryOperator jarg4, int jarg5)`
`static long`	mainJNI.`Solver_makeOperator__SWIG_7(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_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_0(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] 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_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_1(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, java.util.function.LongBinaryOperator 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_makePathCumul__SWIG_2(long jarg1, Solver jarg1_, IntVar[] jarg2, IntVar[] jarg3, IntVar[] jarg4, IntVar[] jarg5, java.util.function.LongBinaryOperator jarg6)`
`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_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_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_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_makeSearchLog__SWIG_4(long jarg1, Solver jarg1_, int jarg2, 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_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_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_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_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 long`	IntVar.`swigRelease(IntVar obj)`
`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`	SolutionCollector.`value(int n, IntVar var)` This is a shortcut to get the Value of 'var' in the nth solution.
`long`	Assignment.`value(IntVar var)`
`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 and Description
`BaseLns(IntVar[] vars)`
`ChangeValue(IntVar[] vars)`
`ImprovementSearchLimit(Solver solver, IntVar[] objective_vars, SWIGTYPE_p_std__vectorT_bool_t maximize, double[] objective_scaling_factors, double[] objective_offsets, double improvement_rate_coefficient, int improvement_rate_solutions_distance)`
`ImprovementSearchLimit(Solver solver, 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)`
`ObjectiveMonitor(Solver solver, SWIGTYPE_p_std__vectorT_bool_t maximize, IntVar[] vars, long[] steps)`
`OptimizeVar(Solver solver, boolean maximize, IntVar var, long step)`
`OptimizeVar(Solver solver, SWIGTYPE_p_std__vectorT_bool_t maximize, IntVar[] vars, long[] steps)`
`Pack(Solver s, IntVar[] vars, int number_of_bins)`
`SearchLog(Solver solver, IntVar[] vars, java.lang.String vars_name, double[] scaling_factors, double[] offsets, 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