operator*

public IloNHood operator*(IloNHood nhood1, IloNHood nhood2)

Definition file: ilsolver/iimnhood.h

Include file: <ilsolver/ilosolver.h>

This operator creates a composed neighborhood. The neighborhood formed is the “product” of nhood1 and nhood2. See IloCompose for full documentation of this operator.

operator*

public IlcFloatExp operator*(const IlcFloatExp exp1, IlcFloat exp2)

public IlcIntExp operator*(const IlcIntExp exp1, IlcInt exp2)

public IlcIntExp operator*(IlcInt exp1, const IlcIntExp exp2)

public IlcIntExp operator*(const IlcIntExp exp1, const IlcIntExp exp2)

public IlcFloatExp operator*(IlcFloat exp1, const IlcFloatExp exp2)

public IlcFloatExp operator*(const IlcFloatExp exp1, const IlcFloatExp exp2)

public IlcIntToIntStepFunction operator*(const IlcIntToIntStepFunction & f1, IlcInt k)

public IlcIntToIntStepFunction operator*(IlcInt k, const IlcIntToIntStepFunction & f1)

Definition file: ilsolver/linfloat.h

Include file: <ilsolver/ilosolver.h>

This arithmetic operator multiplies its arguments. It has been overloaded to handle constrained expressions appropriately. The domain of the resulting expression is computed from the domains of the combined expressions as you would expect.

Example

The following code from the example sendmory.cpp in the standard distribution creates several constrained expressions.

 IloSolver s;
 IlcIntVar S(s, 1, 9, "S"), E(s, 0, 9, "E"), N(s, 0, 9, "N"),
           D(s, 0, 9, "D"), M(s, 1, 9, "M"), O(s, 0, 9, "O"),
           R(s, 0, 9, "R"), Y(s, 0, 9, "Y");
 IlcIntExp send =            1000*S + 100*E + 10*N + D;
 IlcIntExp more =            1000*M + 100*O + 10*R + E;
 IlcIntExp money = 10000*M + 1000*O + 100*N + 10*E + Y;

operator*

public IloEvaluator< IloObject > operator*(IloEvaluator< IloObject > left, IloEvaluator< IloObject > right)

public IloEvaluator< IloObject > operator*(IloEvaluator< IloObject > left, IloNum c)

public IloEvaluator< IloObject > operator*(IloNum c, IloEvaluator< IloObject > right)

Definition file: ilsolver/iloselector.h

Include file: <ilsolver/iloselector.h>

These operators create a composite IloEvaluator<IloObject> instance. The semantics of the new evaluator are the multiplication of the values of the component evaluators. The first function combines two evaluators, multiplying their values to generate the combined evaluation. The other two signatures multiply the value returned by the evaluator with an IloNum value.

For more information, see Selectors.

operator*

public IloNumLinExprTerm operator*(const IloNumVar x, IloInt num)

public IloNumLinExprTerm operator*(IloInt num, const IloNumVar x)

public IloNumLinExprTerm operator*(const IloIntVar x, IloNum num)

public IloNumLinExprTerm operator*(IloNum num, const IloIntVar x)

public IloIntLinExprTerm operator*(const IloIntVar x, IloInt num)

public IloNumExprArg operator*(const IloNumExprArg x, const IloNumExprArg y)

public IloNumExprArg operator*(const IloNumExprArg x, IloNum y)

public IloNumExprArg operator*(IloNum x, const IloNumExprArg y)

public IloIntExprArg operator*(const IloIntExprArg x, const IloIntExprArg y)

public IloIntExprArg operator*(const IloIntExprArg x, IloInt y)

Definition file: ilconcert/iloexpression.h

Returns an expression equal to the product of its arguments.

This overloaded C++ operator returns an expression equal to the product of its arguments. Its arguments may be numeric values, numeric variables, or other expressions.

operator*

public IloNumToNumStepFunction operator*(const IloNumToNumStepFunction f1, IloNum k)

public IloNumToNumStepFunction operator*(IloNum k, const IloNumToNumStepFunction f1)

Definition file: ilconcert/ilonumfunc.h

Creates and returns a function equal to its argument function multiplied by a given factor.

These operators create and return a function equal to the function f1 multiplied by a factor k everywhere on the definition interval. The resulting function is defined on the same interval as the argument function f1. See also: IloNumToNumStepFunction.