# Error Messages/40935

## Contents

## Error text examples

The 'Shelf_space' constraint in the structured NLP defined in 'My_opt_def' evaluates to a result containing the following unexpected index(es): 'Product'.

## Cause

While an optimization was being solved, a constraint was evaluated and found to have extra, unexpected indexes. There are basically three causes:

- An error in your model's logic -- you may have forgotten to Sum over the index or apply some other array-reducing function.
- You intended there to be an array of constraints - a separate constraint along each of these extra indexes within the same optimization problem.
- Your intention was to array-abstract over these indexes, resulting in multiple optimization problem instances, each solved separately.

## Remedies

The correct remedy depends on which of the above cases fits your situation. For example, let's consider the following constraint that causes this error:

`Ceil(Num_units/Stacking_height)*Unit_width <= Shelf_length`

### Case 1: Need array-reducing function

Suppose that all products need to share the same available shelf space. `Shelf_length`

then does not vary by `Product`

, while `Num_units`

, `Unit_width`

and `Stacking_height`

does. Then it appears that we forgot to Sum by product to compute the total amount of shelf length consumed by all products. When evaluated, the optimizer encountered the unexpected dimension, `Product`

. We can fix the problem by changing our definition to:

`Sum(Ceil(Num_units/Stacking_height)*Unit_width, Product) <= Shelf_length`

### Case 2: Array of constraints

Suppose that a certain amount of shelf space has been allocated to each product type. Hence,`Shelf_length`

varies with `Product`

(i.e., is indexed by `Product`

), and what we really intend is to have an array of constraints all inside the same single optimization problem. In this case, we'll have one `Shelf_space`

constraint for each product.

To do this, we need to tell the optimizer that the index `Product`

is to be included as an optimization dimension for this constraint. There are several ways to do this, each may be convenient in different cases, depending on how you have formulated your constraint.

One general approach is to include the *over* keyword in your inequality expression. Here we've appended it to the end:

`Ceil(Num_units/Stacking_height)*Unit_width <= Linear_shelf_space over Project`

The syntax also allows you to prepend it to the front, or place it next to the inequality as demonstrated by these:

`over Project Ceil(Num_units/Stacking_height)*Unit_width <= Linear_shelf_space`

`Ceil(Num_units/Stacking_height)*Unit_width <= over Project Linear_shelf_space`

The flexibility in syntax so that you can chose the one that is most readable in your particular case. This syntax can be used even if you specify your constraint directly in the parameter of DefineOptimization.

Alternatively, you can leave the constraint as is and list the index in the *OptDimensions* attribute. You can access the *OptDimensions* attribute in the Attribute panel, or in the Object window. However, to view it in the object window, you need to enable the visibility of the *OptDimensions* attribute from the **Attributes...** dialog on the Object menu. The attribute can only be used when your constraint is defined inside a constraint object, or inside a User-Defined Function. You cannot use this method when you specify the inequality expression directly in the «constraints» parameter of DefineOptimization.

### Case 3: Array-abstracting

Suppose there are no interactions between different products in your model. Each product has its own shelf space, and you want to optimize each product separately. In other words, you wish to array-abstract over the *Product* index, and solve a separate optimization problem for each *Product*. The *Shelf_space* constraint, therefore, should be treated as a single constraint in each optimization problem.

However, because `Num_units, Unit_width, Stacking_height`

and `Shelf_length`

are all indexed by `Product`

in your model, `Product`

is an extra dimension here. With array-abstraction, the optimization problem corresponding to the first product should use only the constraint for `[@Product = 1]`

.

To treat `Product`

as an array-abstraction index, you need to indicate this to DefineOptimization using some combination of the «Over» and «SetContext» parameters. In this case, «SetContext» does the job -- we change our optimization definition to:

`DefineOptimization(...; constraints:Self_space,... ; SetContext: Product)`

The «SetContext» parameter imposes certain requirements and restrictions on your model. You may need to refine your own model somewhat in order to utilize «SetContext» effectively.

Enable comment auto-refresher