Elements of an array are identified by their indices along each axis. Let a d-dimensional array A of elemental type T have extent n_j along its j-th axis, j = 0,...,d-1. Then, a valid index i_j along the j-th axis must be greater than or equal to zero and less than n_j. An attempt to reference an element A[i₀,i₁,...,i_d-1] with any invalid index i_j causes an ArrayIndexOutOfBoundsException to be thrown.

Elements of an array are logically ordered with respect to each other according to the following definition. An element A[i₀,i₁,...,i_d-1] of a d-dimensional array A follows an element A[j₀,j₁,...,j_d-1] of the same array if and only if there exists a k greater than or equal to zero and less than d such that i_l=j_l for all l<k and i_k>j_k. In usual nomenclature, this corresponds to row-major (C-style) ordering of the elements.

We propose the development of standard Java classes which implement multidimensional rectangular arrays. The rank and type of an array are defined by its class. That is, for each rank and type there is a different class. (This is necessary for traditional compiler optimizations, since Java does not support templates.) Supported types must include all of Java primitive types (boolean, byte, char, short, int, long, float, and double), one or more complex types (at least the Complex class in the VNI JSR - Add Complex Class to Java), and Object. Supported ranks must include 0- (scalar), 1-, 2-, 3-, 4-, 5-, 6- and 7-dimensional arrays. (Rank 7 is the current standard limit for Fortran.) The class for a d-dimensional array of type would be typeArraydD. As an example, the class for a two-dimensional Array of doubles would be named doubleArray2D. Array classes are final classes.

The array classes must fully support the concept of regular array sections. A regular array section corresponds to a subarray of another array, which we call the master array. Each element of an array section corresponds to exactly one element of its master array. The correspondence is one-to-one in the section to master direction. Referencing one element of an array section (for reading or writing) has the effect of referencing the corresponding element of the master array. Regular array sections have the same type as, and rank less than or equal to, their master arrays. Regular array sections behave exactly like regular arrays for all operations, including sectioning. (In fact, there are no separate classes for array sections.)

The array classes provide methods that implement Fortran-like functionality for arrays. In particular, the following operations must be provided:

• Get and set the values of an array element, array regular section, or array irregular section.
• Operations to query the rank and shape of an array.
• Operations to reshape and transpose an array.
• Elemental conversion functions (e.g., the equivalent of Fortran REAL and AIMAG, that convert complex arrays into double arrays).
• Elemental transcendental functions.
• Elemental relational functions (<, >, <=, >=, ==, !=).
• Array reduction functions (sum, minval, etc.).
• Array construction functions (merge, pack, spread, unpack).
• Array manipulation functions (shift, spread).
• Array location functions (maxloc, minloc).
• Array scatter and gather operations.
• Operations that correspond to array expressions (addition, multiplication, etc.)

Quite often, Java code using the Array package will have to interface with native code. The native code can access the elements of a multidimensional Array using the following mechanism, explained through an example. Let there be a native static void foo(doubleArray2D). The C code for foo needs to do the following:

    foo(JNIEnv *env, jobject arr)
    {

        /*
         * Find the number of elements in the Array.
         */
        jsize len = GetMDArrayLength(env, arr);
        ...

        /*
         * Obtain a pointer to the elements of the Array.
	 * The elements are in increasing element order.
         */
        jdouble *data = GetDoubleMDArrayElements(env, arr);

	/*
         * Operate on data as desired.
         */
        ...

        /*
         * Release the Array elements when done.
         */
        ReleaseDoubleMDArrayElements(env, arr, data);
        return;
    }
    

A good implementation of the Array package will deliver high performance in the execution of aggregate methods. That is, methods that operate on many elements, such as adding two array sections or multiplying two matrices. The techniques for performing efficient aggregate operations on matrices, in particular for linear algebra operations, are well described in the literature.

To deliver good performance on user codes that use elementary operations on array elements, two compiler technologies are of utmost importance:

1. Bounds checking optimization through versioning: This technique creates safe regions of code where all array accesses are guaranteed to be valid. Aggressive optimizations, that reorder code, can be applied in these regions.
2. Semantic expansion: With the array package, each elemental data access (set or get) operation is a method call. The method verifies that all the indices are valid (along each of the array axes) before proceeding to the actual data access. Exposing the semantics of these methods to the compiler is a necessary step for optimization. This is accomplished through the technique of semantic expansion.

A prototype research compiler that performs the optimizations of semantic expansion and bounds checking optimization has been implemented at IBM Research.

Two technical reports describing the design of the strawman Array package are available:

1. IBM Research Division RC21369. A Standard Java Array Package for Technical Computing. Jose Moreira, Sam Midkiff, Manish Gupta.
2. IBM Research Division RC21481. Java Programming for High Performance Numerical Computing. Jose Moreira, Sam Midkiff, Manish Gupta, Pedro Artigas, Marc Snir, Rick Lawrence.