• The Idea:
  • You often need to perform calculations on the elements of an array that "near" a particular element
• Involving Arrays:
  • We need to perform an operation on the elements to the left and/or right of a given element
• Involving Arrays of Arrays:
  • We need to perform an operation on the elements surrounding a given element

• Using the Subarrays Pattern:
  • The subset would be described using an offset and length for each dimension
• A Shortcoming:
  • It is not consistent with the way domain experts think about the problem

• Involving Arrays:
  • Domain experts think about the middle element and the size (which is usually odd, meaning there are the same number of elements to the left and right)
• Involving Arrays of Arrays:
  • Domain experts think about the middle element (which has a row and column) and a single odd size (making the neighborhood square)

• The Idea:
  • Add parameters to the signature of the method
• For Arrays:
  • An index and a size
• For Arrays of Arrays:
  • A row, col, and size

javaexamples/programmingpatterns/Neighborhoods.java (Fragment: 0)

    /**
     * Calculate the average of the elements of the data array that
     * are in a neighborhood (of a given size) of a particular element.
     *
     * @param data  The data array
     * @param index The element in the middle of the neighborhood
     * @param size  The size of the neighborhood (which must be odd)
     * @return The average
     */
    public double naverage(double[] data, int index, int size) {
        double total;
        int    start, stop;

        start = index - size / 2;
        stop  = index + size / 2; // Equivalently: stop = start + size - 1
        total = 0.0;
        for (int i = start; i <= stop; i++) {
            total += data[i];
        }
        return total / (double) size;
    }
        

javaexamples/programmingpatterns/Neighborhoods.java (Fragment: 1)

    /**
     * Calculate the average of the elements of the data matrix that
     * are in a square neighborhood (of a given size) of a particular
     * element.
     *
     * @param data  The data array
     * @param row   The row of the element in the center of the neighborhood
     * @param col   The column of the element in the center of the neighborhood
     * @param size  The size of the neighborhood (which must be odd)
     * @return The average
     */
    public double naverage(double[][] data, int row, int col, int size) {
        double total;
        int    cstart, cstop, rstart, rstop;

        rstart = row - size / 2;
        rstop  = row + size / 2;
        cstart = col - size / 2;
        cstop  = col + size / 2;

        total = 0.0;
        for (int r = rstart; r <= rstop; r++) {
            for (int c = cstart; c <= cstop; c++) {
                total += data[r][c];
            }
        }
        return total / (double) (size * size);
    }
        

javaexamples/programmingpatterns/Neighborhoods.java (Fragment: 3)

    /**
     * Calculate the average of the elements of the data matrix that
     * are in a square neighborhood (of a given size) of a particular
     * element excluding the element at the center of the neighborhood.
     *
     * @param data  The data array
     * @param row   The row of the element in the center of the neighborhood
     * @param col   The column of the element in the center of the neighborhood
     * @param size  The size of the neighborhood (which must be odd)
     * @return The average
     */
    public double xnaverage(double[][] data, int row, int col, int size) {
        double total;
        int    cstart, cstop, rstart, rstop;

        rstart = row - size / 2;
        rstop  = row + size / 2;
        cstart = col - size / 2;
        cstop  = col + size / 2;

        total = 0.0;
        for (int r = rstart; r <= rstop; r++) {
            for (int c = cstart; c <= cstop; c++) {
                if ((row != r) || (col != c)) {
                    total += data[r][c];
                }
            }
        }
        return total / (double) (size * size - 1.0);
    }
        

javaexamples/programmingpatterns/Neighborhoods.java (Fragment: 2)

    /**
     * Calculate the average of the elements of the data matrix that
     * are in a plus-sign-shaped neighborhood (of a given size) of a
     * particular element.
     *
     * @param data  The data array
     * @param row   The row of the element in the center of the neighborhood
     * @param col   The column of the element in the center of the neighborhood
     * @param size  The size of the neighborhood (which must be odd)
     * @return The average
     */
    public double paverage(double[][] data, int row, int col, int size) {
        double total;
        int    count, cstart, cstop, rstart, rstop;

        rstart = row - size / 2;
        rstop  = row + size / 2;
        cstart = col - size / 2;
        cstop  = col + size / 2;

        total = 0.0;
        count = 0;        
        for (int r = rstart; r <= rstop; r++) {
            total += data[r][col];
            ++count;
        }

        for (int c = cstart; c <= cstop; c++) {
            total += data[row][c];
            ++count;
        }

        // Eliminate the double counting
        total -= data[row][col];
        --count;
        
        return total / (double) count;
    }