One of the nice things is that you can actually use the information from the tree structure in your model: each section or declaration section that you introduce in your model will automatically create a new set in AIMMS with the same name as the section. This new set is a subset of the predefined set AllIdentifiers and it will contain all identifiers that are declared under the section or declaration section.

Example of structured model tree

• Input_Section
• Set_declarations
• Location_declarations
• Transport_declarations
• Output_Section

As you can see from the above list, AIMMS will convert the spaces in the names of the (declaration) sections into underscores. This conversion is done because identifiers in AIMMS cannot contain spaces.

From the above list, you can also see that no separate set is created for the declaration section “Declaration” under the section Output Section. The reason for this is that no two identifiers in AIMMS can have the same name. The only exception to this rule is declaration sections that can all share the name Declaration. This means that for declaration sections, AIMMS will only automatically create the subset of AllIdentifiers if it has a different name than the default name Declaration.

The set Set_declarations from the example above will only contain the element ‘Locations’. The set Input_Section will not only contain all the identifiers declared under it explicitly, but it will also contain the sets that are automatically created because of the (declaration) sections under it. This means that it will also contain the elements ‘Set_Declarations’, ‘Location_declarations’, and ‘Transport_declarations’.

Note that any of the indices declared with sets are seen as separate elements in the set. For example, the set Locations has three indices: loc, locFrom, and locTo. These three indices will be three separate elements in both the sets Input_Section and Set_declarations.

A typical example use for these automatically created sets is that you are able to empty specific parts of your model. For example, if you want to empty all the identifiers in your model that are related to input, you can do so with the following statement:

empty Input_Section ;

Similarly, with the write statement you can also write the contents of all identifiers declared under the given section to a file as follows:

write Input_Section to file "values_of_identifers_under_Input.txt" ;

If you want to see the exact contents of such a automatically created set, you can assign its contents to a set you declared in your model. Please keep in mind that you will have to declare this set to be a subset of AllIdentifiers. If you have such a subset of AllIdentifiers, e.g. mySubSet, you can use the following statement:

mySubSet := Input_Section ;

to assign the contents of the automatically created set to the set mySubset, after which you can inspect the data of mySubSet.

You can enable the display of line numbers in the editor settings, which you can access via Editor Settings… under the Settings menu. If you go to the Misc tab, you will see the following options:

AIMMS IDE Editor settings

By changing the value for the setting LineNumberMargin to True, AIMMS will display the line numbers for all the attributes that can consist of multiple lines. The result will look like the image below:

Line numbers displayed in multiple line attribute

Jump to specific line number by pressing Ctrl+g

Alternatively, you can open the same dialog via Goto Line… under the Edit menu.

Note that this Goto line function works regardless of whether the line numbers are displayed or not.

Of course, you can manually copy all of these attributes to a separate text editor window, but this is a rather cumbersome approach. Another approach is to put the identifiers you want to have the text representation for in a separate section and use the information in the article Exporting a section and importing it in another AIMMS project to export this section to an .aim file. Unfortunately, this approach also requires quite some additional steps.

View selected identifiers as text

You can also select multiple identifiers in the model tree by pressing the Ctrl key while selecting the additional identifiers in the tree.

The resulting new tab page that is opened will look something like the image below:

Text representation of selected identifiers

If you double-click on the icon of the identifier that supports child identifiers (e.g. Section, Declaration Section, etc.), AIMMS will open the identifier node in the tree and show the child identifiers. In case of double-clicking on the icon of an identifier that does not support an underlying sub-tree, AIMMS will just open the attribute form (e.g. double-clicking on the [P] icon of a parameter identifier will just open the attribute form of the parameter).

Quickly expand all sub-trees

One of the lesser known features of AIMMS is that you can quickly expand all sub-trees that are below a selected identifier (e.g. a Section identifier). You can do this by pressing the CTRL key on your keyboard while double-clicking the icon of the identifier that can contain a sub-tree (e.g. Section).

An example of this is shown in the picture on the right. Note that you can do this at any point in your model tree. All the identifiers that are not in the sub-tree of the currently selected identifier will stay as they were, only the complete sub-tree under the currently selected identifier is expanded. Holding the CTRL key while using the right cursor key on the keyboard will have the same result (i.e. expand all sub-trees below the currently selected identifier).

Quickly expand all sub-trees except declaration sections

You can do this in AIMMS by not pressing the CTRL key while double-clicking on the identifier icon (or using the right cursor key), but pressing the Shift key. The picture on the left will show the result after pressing the Shift key while double-clicking on the book-icon in front of Section 1.

Recursion: See Recursion

I think that for most of the API functions provided by the libaimms.dll it is not very useful if you call them from within AIMMS again via this way. However, one of the methods in the DLL is AimmsProcedureHandleCreate, which creates a handle to an AIMMS procedure in the project. When you call this method, you will also get some information about the number of arguments and the type of each of these arguments.

To be able to call the AimmsProcedureHandleCreate (and the corresponding AimmsProcedureHandleDelete to delete the handle again afterwards) method from the libaimms.dll, you have to introduce the following two external procedure in your AIMMS project:

EXTERNAL PROCEDURE
  identifier  :  AimmsProcedureHandleCreate
  arguments   :  (theProcedure,theHandle,nArgs,argType)
  dll name    :  "libaimms.dll"
  return type :  integer
  body call   :  AimmsProcedureHandleCreate(
                     scalar string : theProcedure,
                     scalar integer : theHandle,
                     scalar integer : nArgs,
                     array integer : argType
                   )
 
  DECLARATION SECTION 
 
    ELEMENT PARAMETER:
       identifier   :  theProcedure
       range        :  AllProcedures
       property     :  Input ;
 
    PARAMETER:
       identifier   :  theHandle
       property     :  Output ;
 
    PARAMETER:
       identifier   :  nArgs
       property     :  Output ;
 
    PARAMETER:
       identifier   :  argType
       index domain :  iArgType
       property     :  Output ;
 
    SET:
       identifier   :  sArgTypes
       index        :  iArgType ;
 
  ENDSECTION  ;
 
 
ENDPROCEDURE  ;
 
 
 
EXTERNAL PROCEDURE
  identifier  :  AimmsProcedureHandleDelete
  arguments   :  (theHandle)
  dll name    :  "libaimms.dll"
  return type :  integer
  body call   :  AimmsProcedureHandleDelete(
                     scalar integer : theHandle
                   )
 
  DECLARATION SECTION 
 
    PARAMETER:
       identifier :  theHandle
       property   :  Input ;
 
  ENDSECTION  ;
 
 
ENDPROCEDURE  ;

As you can see, the DLL that is used is the libaimms.dll. These two external procedures can then be used by one final procedure CheckProcedurePrototype that will check whether the procedure it gets as an argument has a certain prototype. The source of this procedure is the following:

PROCEDURE
  identifier :  CheckProcedurePrototype
  arguments  :  (theProcedure)
 
  DECLARATION SECTION
 
    PARAMETER:
       identifier   :  pProcHandle ;
 
    PARAMETER:
       identifier   :  pNumArgs ;
 
    SET:
       identifier   :  sProcArgs
       index        :  iProcArgs
       initial data :  !The maximum number of arguments we want to support
                       {0..512} ;
 
    PARAMETER:
       identifier   :  pProcArgType
       index domain :  (iProcArgs) ;
 
    PARAMETER:        
       identifier   :  pResult ;
 
    ELEMENT PARAMETER:
       identifier   :  theProcedure
       range        :  AllProcedures
       property     :  Input ;
 
  ENDSECTION  ; 
 
  body       :  
    !Create handle to the procedure. When calling the
    !API, we automatically get all the information about the
    !arguments of this procedure
    pResult := AimmsProcedureHandleCreate(
                    theProcedure :  theProcedure,
                    theHandle    :  pProcHandle,
                    nArgs        :  pNumArgs,
                    argType      :  pProcArgType ) ;
 
    if pResult then 
            !If the API call was successful, we must delete the handle
            AimmsProcedureHandleDelete(theHandle : pProcHandle ) ;
 
            !Now we can check the actual prototype. The meaning of the values
            !in the pProcArgType parameter, can be found in the libaimms.h
            !file in your AIMMS installation. The relevant parts are:
 
            !       #define AIMMSAPI_STORAGE_HANDLE  0x00000000
            !       #define AIMMSAPI_STORAGE_DOUBLE  0x00000001
            !       #define AIMMSAPI_STORAGE_INT     0x00000002
            !       #define AIMMSAPI_STORAGE_BINARY  0x00000003
            !       #define AIMMSAPI_STORAGE_STRING  0x00000004
            !
            !       #define AIMMSAPI_INPUT           0x00000010
            !       #define AIMMSAPI_OUTPUT          0x00000020
            !       #define AIMMSAPI_INPUT_OUTPUT    0x00000040
 
 
            !For example, we want 1argument and it must be a string parameter
            !that is input only. This means that we have to OR the value
            !0x04 (STORAGE_STRING) and 0x10 (INPUT) to get the value 0x14
            !0x14 (hex) => 20 (decimal)
            if pNumArgs = 1 and pProcArgType( first(iProcArgs) ) = 20 then
                    return 1 ;
            endif ;
    endif ;
 
    !If the API call was not successful, or the prototype of the
    !procedure was not correct, return the value 0
    return 0 ;
 
ENDPROCEDURE  ;

For more details about the AIMMS API and the above used methods, please take a look at the AIMMS documentation.

Dicslaimer: Though the above code works (and I had a smile on my face when I found this possibility ), I would like to point out that you have to be extremely careful when calling the AIMMS API from within AIMMS this way: very quickly, you can end up in unpredictable situations because of the locking mechanisms used.

You can download the source of the above (external) procedures from the link below:

A better approach, which I guess is used most often, is to use a repetitive loop (for, while, repeat) and declare a new local parameter for this procedure that will be used to keep track of how many iterations have been done in the loop. To execute a block of statements times, you will first have to initialize this counter parameter to 0 or 1 (depending on your preference to start counting at 0 or 1) and then use a while-loop with a termination criteria to execute the statements repetitively. Furthermore, you must also ensure that you increment the value of your local counter parameter with one in each iteration. So if you declare the additional parameter myLoopCounter, the required code will look like:

!Initialize the myLoopcounter to the value 1
myLoopCounter := 1 ; 
while myLoopcounter <= 3 do
    DialogMessage("Current iteration " + myLoopCounter ) ; 
    !And increment the counter by one
    myLoopCounter += 1 ; 
endwhile ;

An even easier approach (but probably far less known) that does not require you to declare any temporary local parameters, is to make use of the predefined LoopCount operator in AIMMS. With repetitive loops like while, for, and repeat, this LoopCount operator will automatically be incremented each time the loop is run. Using the LoopCount operator, the above code could be transformed into the following:

while LoopCount <= 3 do
	dialogMessage("Current iteration " + LoopCount) ; 
endwhile ;

If you have multiple nested loops, you can name each of these loops by using a loop string in the statement. You can access the value of a LoopCount corresponding to one particular of the nested loops by providing the loop string name as an argument to the LoopCount. If you do not provide any loop string, the LoopCount operator returns the value of the closest repetitive loop. If you run the example code below, you will see that when not providing a loop string, the value returned by the LoopCount operator is the same as the LoopCount for the inner-loop because this is the closest repetitive loop.

while LoopCount <= 3 do "outer-loop"
    while LoopCount <= 4 do "inner-loop" 
        dialogMessage( "Outer : " + LoopCount("outer-loop") 
                       + "\n"
                       + "Inner : " + LoopCount("inner-loop")
                       + "\n"
                       + "No string : " + LoopCount
                      ) ; 
    endwhile ; 
endwhile ;

Default splashscreen for AIMMS Developer

Gate Assignment splashscreen

The name of the .prj file of the gate assignment project is “Gate Assignment.prj”. By saving the above picture as “Gate Assignment.bmp” in the same folder as the “Gate Assignment.prj” file, AIMMS will now display the new splashscreen. Please note that you must use the bitmap (BMP) format, as AIMMS will only look for this extension (and not other image file formats).

A data page can be opened via the Data button, via the right mouse menu, or via shortcut key Ctrl + D for every global identifier.

Multi-dimensional parameters, variables and constraints are displayed in Pivot Table by default.  Using the  button on the data page you can switch view among Pivot Table, Composite Table, Table, and Sparse List .  For example, the following is the Composite Table view of the 2-dimensional data “Transport” in the “Transport Model” example.

On the above page, via the Selection Object on the top, you can select any given d (Depot) and c (Customer) to view the value.

If you want to add other identifiers to the same table, for example, adding “UnitTransportCost” to the above table, you can easily do so in three steps: 1. Switch the data page to “Edit” Mode; 2. select “UnitTransportCost” in the Model Explorer by mouse; 3. drag and drop “UnitTransportCost” to the table.

After mouse releases, you will see “UnitTransportCost” shows in the table.

You can add an identifier to other types of table in the same way. And in page Edit Mode, you can change other properties of the table in the table Properties Dialog, for example, adding or removing suffices, editing format, etc.

After the changes, you can save the modified data page. The saved data page will appear under All Data Pages section in the Page Manager.

Please note if a modified data page exists, which is with format “[Data Page] Identifier Name”,  AIMMS will use this page as the data page for that identifier. In order to view the default data page,  you need to hold down the Shift key while opening the data page, or remove the data page from the All Data Pages section.

50 * min( aParameter, aVariable).

The idea of using this binary min operator was to introduce a ceiling to the contribution of a variable to the objective. Recently, I also saw a similar topic being discussed by Erwin Kalvelagen in his max tricks blog post.

If you want to keep your problem linear, you cannot make use of the min operator directly in a constraint, so you will have to work around it with some modelling. You can do this introducing a new variable min_param_var, that will be forced to have a value equal to the binary min-operator by using additional constraints. This new variable will replace the original “min( aParameter, aVariable)” term in the objective (and thus will have coefficient of 50 in objective in the above example).

Furthermore, we also need a new binary variable param_smaller_than_var, that will get the value 1 if the value of the parameter is smaller than the value of the variable and 0 otherwise.

Finally, we also need to add two constraints and a big-M to the model to ensure the newly introduced variables get the correct values. The value of the big-M should be a sufficiently large value, which in this particular case is max( aParameter, aVariable.upper ).

The 2 constraints you will have to add are:

If the variable min_param_var has a positive component in the objective, the solver will try to minimize the value of the variable min_param_var and the above constraints will ensure that the variable param_smaller_than_var will automatically get the value 1 if aParameter <= aVariable and 0 otherwise.

By filling in some values for the parameter and the variable in the above constraints, you can verify that the binary variable must indeed get the correct value to ensure that the min_param_var variable will get the smallest value possible.

Additional information: In case you are minimizing an objective that contains a binary max operator, you can use a similar approach. However, in this case you do not need the big-M, but only one additional variable max_param_var and two constraints:

Screenshot AimmsInterrupt

However, if you only make use of installation-free versions of AIMMS, nothing is added to the Start Menu, meaning there is no direct way to start the tool. Luckily, it is still possible to start the AimmsInterrupt tool from within AIMMS itself. If you start an installation-free version of AIMMS you can put the following statement in a procedure:

execute("c:\\Program Files\\Paragon Decision Technology\\Common\\Bin\\AimmsInterrupt.exe") ;

When you execute this procedure, the AimmsInterrupt tool will be started, from which you can now interrupt any of the AIMMS sessions that is running.