void deryabin_m_cannons_algorithm_mpi::CannonsAlgo...

Для того чтобы разбить вашу функцию DistributeDataIfRoot() на две логически разделённые функции, можно выделить два основных этапа:

1. Копирование блоков данных в локальные массивы — здесь происходит распределение части данных для текущего процесса (или узла).
2. Отправка данных между процессами — здесь данные передаются другим процессам (или узлам), чтобы они могли работать с необходимыми частями матриц.

Таким образом, можно выделить две функции:

• Одна будет отвечать за копирование данных в локальные массивы.
• Вторая будет ответственна за отправку данных другим процессам.

1. Функция для копирования данных:

cpp
void deryabin_m_cannons_algorithm_mpi::CannonsAlgorithmMPITaskParallel::CopyDataToLocalMatrices()
{
    for (unsigned short k = 0; k < block_dimension_; ++k) {
        std::copy(
            input_matrix_A_.data() + (k * dimension_),
            input_matrix_A_.data() + (k * dimension_) + block_dimension_,
            local_input_matrix_A_.begin() + (k * block_dimension_)
        );
        std::copy(
            input_matrix_B_.data() + (k * dimension_),
            input_matrix_B_.data() + (k * dimension_) + block_dimension_,
            local_input_matrix_B_.begin() + (k * block_dimension_)
        );
    }
}

2. Функция для отправки данных между процессами:

cpp
void deryabin_m_cannons_algorithm_mpi::CannonsAlgorithmMPITaskParallel::SendDataToOtherProcesses()
{
    for (unsigned short i = 0; i < block_rows_columns_; ++i) {
        for (unsigned short j = 0; j < block_rows_columns_; ++j) {
            if (i == 0 && j == 0) {
                continue;
            }
            for (unsigned short k = 0; k < block_dimension_; ++k) {
                int destination_proc = (i * block_rows_columns_) + j;
                if (i == 0) {
                    world_.send(
                        destination_proc,
                        0,
                        input_matrix_A_.data() + ((i * block_dimension_ + k) * dimension_) + (j * block_dimension_),
                        block_dimension_
                    );
                } else {
                    if (static_cast<int>((i * block_rows_columns_) + j - i) < static_cast<int>(i * block_rows_columns_)) {
                        world_.send(
                            destination_proc + block_rows_columns_ - i,
                            0,
                            input_matrix_A_.data() + ((i * block_dimension_ + k) * dimension_) + (j * block_dimension_),
                            block_dimension_
                        );
                    } else {
                        world_.send(
                            destination_proc - i,
                            0,
                            input_matrix_A_.data() + ((i * block_dimension_ + k) * dimension_) + (j * block_dimension_),
                            block_dimension_
                        );
                    }
                }
                if (j == 0) {
                    world_.send(
                        destination_proc,
                        1,
                        input_matrix_B_.data() + ((i * block_dimension_ + k) * dimension_) + (j * block_dimension_),
                        block_dimension_
                    );
                } else {
                    if ((static_cast<int>((i - j) * block_rows_columns_) + j) < 0) {
                        world_.send(
                            ((i + block_rows_columns_ - j) * block_rows_columns_) + j,
                            1,
                            input_matrix_B_.data() + ((i * block_dimension_ + k) * dimension_) + (j * block_dimension_),
                            block_dimension_
                        );
                    } else {
                        world_.send(
                            ((i - j) * block_rows_columns_) + j,
                            1,
                            input_matrix_B_.data() + (((i * block_dimension_) + k) * dimension_) + (j * block_dimension_),
                            block_dimension_
                        );
                    }
                }
            } 
        }
    }
}

Разделение функций:

1. CopyDataToLocalMatrices — эта функция занимается копированием данных из глобальных матриц в локальные массивы для обработки.
2. SendDataToOtherProcesses — эта функция отвечает за отправку данных между процессами в распределённой системе.

Теперь ваша основная функция DistributeDataIfRoot() будет выглядеть так:

cpp
void deryabin_m_cannons_algorithm_mpi::CannonsAlgorithmMPITaskParallel::DistributeDataIfRoot()
{
    CopyDataToLocalMatrices();
    SendDataToOtherProcesses();
}

Таким образом, код становится более читаемым и поддерживаемым, с разделением логики на две части.