Function collapse_array

src/array_slice.cpp:554–597

data_size = 1,2 for real,complex-valued array

// data_size = 1,2 for real,complex-valued array
realnum *collapse_array(realnum *array, int *rank, size_t dims[3], direction dirs[3], volume where,
                        int data_size = 1) {

  /*--------------------------------------------------------------*/
  /*- detect empty dimensions and compute rank and strides for    */
  /*- collapsed array                                             */
  /*--------------------------------------------------------------*/
  int full_rank = *rank;
  size_t reduced_dims[3], reduced_stride[3], stride[3]; // the latter for non-reduced array strides
  direction reduced_dirs[3];
  size_t reduced_grid_size;
  int reduced_rank;
  reduce_array_dimensions(where, full_rank, dims, dirs, stride, reduced_rank, reduced_dims,
                          reduced_dirs, reduced_stride);

  if (full_rank == 0) return array;
  if (reduced_rank == full_rank) return array; // nothing to collapse

  /*--------------------------------------------------------------*/
  /*- allocate reduced array and compress full array into it     -*/
  /*--------------------------------------------------------------*/
  reduced_grid_size = reduced_dims[0] * reduced_dims[1] * reduced_dims[2];
  size_t reduced_array_size = data_size * reduced_grid_size;
  realnum *reduced_array = new realnum[reduced_array_size];
  if (!reduced_array)
    meep::abort("%s:%i: out of memory (%zu)", __FILE__, __LINE__, reduced_array_size);
  memset(reduced_array, 0, reduced_array_size * sizeof(realnum));

  size_t n[3] = {0, 0, 0};
  do {
    size_t index = n[0] * stride[0] + n[1] * stride[1] + n[2] * stride[2];
    size_t rindex = n[0] * reduced_stride[0] + n[1] * reduced_stride[1] + n[2] * reduced_stride[2];
    for (int i = 0; i < data_size; i++)
      reduced_array[data_size * rindex + i] += array[data_size * index + i];
  } while (!increment(n, dims, full_rank));

  *rank = reduced_rank;
  for (int r = 0; r < reduced_rank; r++) {
    dims[r] = reduced_dims[r];
    dirs[r] = reduced_dirs[r];
  }
  delete[] array;
  return reduced_array;
}

complex<realnum> *collapse_array(complex<realnum> *array, int *rank, size_t dims[3],
                                 direction dirs[3], volume where) {