Exceptions to the standard

  In one situation it is allowed to deviate from the FORTRAN standard. It concerns the passing of arrays to underlying subroutines. On one hand it is allowed that the number and size of the dimensions of an actual array are different from the number and size of the associated dummy argument declarator, on the other hand it is allowed to pass arrays through their starting address. In both situations we utilize explicitly the FORTRAN property that passing an array is effectively the passing of the starting address.
The use of this possibility is of course against any rule with respect to "clean" programming and should be avoided as much as possible. However in any large FORTRAN computing package it is common practice to use this option. Reasons for this exception are for example:

• In a specific subroutine, the use of an array as n-dimensional array is the most attractive because of structured programming (for example in the building of the matrix). In another subroutine this same array can be better be considered as an m-dimensional array (for example in the linear solver).
  If we would use the same dimension, then it would be necessary to compute starting addresses, which is not efficient and moreover, does not improve the readableness.
• The reason to pass arrays through their starting addresses is that through this option the number of parameters in an upper subroutine may be decreased drastically. For that reason the number of errors may be decreased. In an under subroutine, however, it may be useful to use more arrays because of readableness.
• In many large packages all information is stored in a large buffer array. All subarrays are dimensioned by the package itself, the user has nothing to do with it. An advantage of this approach is that the user does not have to declare his own arrays, does not need to know anything about help arrays and as a consequence produces less errors. The package takes care of memory management.

It will be clear that this approach is very dangerous. For that reason it is only allowed to use in the highest level of subroutines. All underlying subroutines must be "clean". Another consequence of this approach is that array bounds must be checked carefully, since checkers nor debuggers are able to perform their task in a correct way.
An extra aspect is important if integers and double precisions are stored in the same integer buffer array. Since doubles take two times the number of positions as integers, it is necessary that each double starts at an odd position in the array. If this is not the case, a double may be placed in two memory segments at a time and unwanted, incomprehensible messages may be the result.