Применить функцию memmove к трехмерному массиву

Я считаю, что вы хотите что-то подобное:

memmove(tempa, te + (a - aa), sizeof(double**) * aa);
memmove(tempa + aa, te, sizeof(double**) * (a - aa));

или же

memmove(tempa, te + aa, sizeof(double**) * (a - aa));
memmove(tempa + (a - aa), te, sizeof(double**) * aa);

в зависимости от того, хотите ли вы поменять местами первую половину «с округлением в большую или меньшую сторону» (я полагаю, вы хотите, чтобы она была округлена в большую сторону, тогда это первая версия).

Мне не очень нравится дизайн вашего кода:

Прежде всего, избегайте динамического размещения и использования std::vector или же std::array когда возможно.
Вы можете утверждать, что это помешает вам безопасно использовать memmove вместо swap для первых измерений (ну, это должно сработать, но я не уверен на 100%, что это не определено реализацией), но я не думаю, что это значительно повысило бы эффективность.
Кроме того, если вы хотите иметь N-мерный массив, я обычно предпочитаю избегать «указателей цепочки» (хотя с вашим алгоритмом вы можете использовать эту структуру, так что это не так уж плохо).
Например, если вы непреклонны в динамическом распределении массива с помощью new, вместо этого вы можете использовать что-то подобное, чтобы уменьшить использование памяти (хотя разница может быть незначительной; это также, вероятно, немного быстрее, но опять же, вероятно, незначительно):

#include <cstddef>
#include <iostream>

typedef std::size_t index_t;

constexpr index_t width = 3;
constexpr index_t height = 4;
constexpr index_t depth = 5;

// the cells (i, j, k) and (i, j, k+1) are adjacent in memory
// the rows (i, j, _) and (i, j+1, _) are adjacent in memory
// the "slices" (i, _, _) and (i+1, _, _) are adjacent in memory
constexpr index_t cell_index(index_t i, index_t j, index_t k) {
return (i * height + j) * depth + k;
}

int main() {
int* array = new int[width * height * depth]();
for( index_t i = 0 ; i < width ; ++i )
for( index_t j = 0 ; j < height ; ++j )
for( index_t k = 0 ; k < depth ; ++k ) {
// do something on the cell (i, j, k)
array[cell_index(i, j, k)] = i + j + k;
std::cout << array[cell_index(i, j, k)] << ' ';
}
std::cout << '\n';
// alternatively you can do this:
//*
for( index_t index = 0 ; index < width * height * depth ; ++index) {
index_t i = index / (height * depth);
index_t j = (index / depth) % height;
index_t k = index % depth;
array[index] = i + j + k;
std::cout << array[index] << ' ';
}
std::cout << '\n';
//*/
delete[] array;
}

Разница в организации в памяти. Здесь у вас есть большой блок размером 60 * (int) байтов (обычно 240 или 480 байтов), тогда как с вашим методом вы получите:
— 1 блок размером 3 * байта (int **)
— 3 блока по 4 * размера (int *) байта
— 12 блоков размером 5 * (int) байтов
(Еще 120 байтов в 64-битной архитектуре, две дополнительные косвенные ссылки для каждого доступа к ячейке и больше кода для выделения / освобождения всей этой памяти)
Конечно, вы не можете делать массив [i] [j] [k] больше, но все же …

То же самое стоит с vectors (вы можете сделать std::vector<std::vector<std::vector<int>>> или std::vector<int>)

Здесь также слишком много повторений кода: ваш алгоритм в основном меняет две половины таблицы три раза (по одному разу для каждого измерения), но вы переписывали 3 раза одну и ту же вещь с небольшими отличиями.

Существует также слишком много выделения / копирования памяти (ваш алгоритм работает и может использовать структуру массива указателей, просто меняя указатели, чтобы поменять местами целые строки / фрагменты, в этом конкретном случае вы Можно использовать эту структуру данных, чтобы избежать копирования с помощью вашего алгоритма … но вы не)

Вы должны выбрать более явные имена переменных, это помогает. Например использовать width, height, depth вместо a, b, c,

Например, вот реализация с векторами (хотя я не знал функцию fftshift в matlab, но в соответствии с вашим кодом и этим страница, Я предполагаю, что это в основном «обмен углами»):

(также скомпилируйте с -std = c ++ 11)

#include <cstddef>
#include <iostream>
#include <vector>
#include <algorithm>

typedef std::size_t index_t;
typedef double element_t;
typedef std::vector<element_t> row_t;
typedef std::vector<row_t> slice_t;
typedef std::vector<slice_t> array_3d_t;

// for one dimension
// you might overload this for a std::vector<double>& and use memmove
// as you originally wanted to do here
template<class T>
void fftshift_dimension(std::vector<T>& row)
{
using std::swap;
const index_t size = row.size();
if(size <= 1)
return;
const index_t halved_size = size / 2;
// swap the two halves
for(index_t i = 0, j = size - halved_size ; i < halved_size ; ++i, ++j)
swap(row[i], row[j]);
// if the size is odd, rotate the right part
if(size % 2)
{
swap(row[halved_size], row[size - 1]);
const index_t n = size - 2;
for(index_t i = halved_size ; i < n ; ++i)
swap(row[i], row[i + 1]);
}
}

// base case
template<class T>
void fftshift(std::vector<T>& array) {
fftshift_dimension(array);
}

// reduce the problem for a dimension N+1 to a dimension N
template<class T>
void fftshift(std::vector<std::vector<T>>& array) {
fftshift_dimension(array);
for(auto& slice : array)
fftshift(slice);
}

// overloads operator<< to print a 3-dimensional array
std::ostream& operator<<(std::ostream& output, const array_3d_t& input) {
const index_t width = input.size();
for(index_t i = 0; i < width ; i++)
{
const index_t height = input[i].size();
for(index_t j = 0; j < height ; j++)
{
const index_t depth = input[i][j].size();
for(index_t k = 0; k < depth; k++)
output << input[i][j][k] << ' ';
output << '\n';
}
output << '\n';
}
return output;
}

int main()
{
constexpr index_t width = 3;
constexpr index_t height = 4;
constexpr index_t depth = 5;

array_3d_t input(width, slice_t(height, row_t(depth)));

// initialization
for(index_t i = 0 ; i < width ; ++i)
for(index_t j = 0 ; j < height ; ++j)
for(index_t k = 0 ; k < depth ; ++k)
input[i][j][k] = i + j + k;
std::cout << input;

// in place fftshift
fftshift(input);

std::cout << "and then" << '\n' << input;
}

живой пример

Возможно, вы могли бы сделать чуть более эффективный алгоритм, избегая многократного обмена одной и той же ячейкой и / или используя memmove, но я думаю, что он уже достаточно быстр для многих применений (на моей машине fftshift занимает примерно 130 мс для таблицы 1000x1000x100).