Переверните матрицу fortran

Question

Я хочу перевернуть мою матрицу вверх. Так что T (1,1) = C (2,1)

Я сделал эту программу, и я нашел код, который должен делать это в Интернете, то есть C=T(2:1:-1, :) Но когда вы пытаетесь получить значение C (1 , 1), который должен быть 3, я получаю 1.3533635457363350E-306. Как вы переворачиваете матрицу таким образом, что вверх становится вниз?

program main 


implicit none 
    integer iMax, jMax 
    double precision, dimension(:,:), allocatable :: T,C 

double precision x, dx,f,L2old,L2norm 

integer i, j,n 


allocate(T(0:2, 0:2)) 
allocate(C(0:2, 0:2)) 


T(1,1)=1 
T(1,2)=2 
T(2,1)=3 
T(2,2)=4 

write(*,*) T(2,2) 

C=T(2:1:-1, :) 

Write(*,*) C(1,2) 


end program main 

Answer 1

Если вы выделяете матрицы нужного размера, тогда все должно работать должным образом.

Например, эта программа

program main 
    implicit none 

    double precision, dimension(:, :), allocatable :: t, c 
    integer :: i 

    allocate (t(1:2, 1:2)) 
    allocate (c(1:2, 1:2)) 

    t = reshape([1, 3, 2, 4], shape(t)) 
    do i = 1, 2 
    write (*, *) t(i, :) 
    end do 
    write (*, *) "" 

    c = t(2:1:-1, :) 
    do i = 1, 2 
    write (*, *) c(i, :) 
    end do 
end program main 

производит следующий вывод

1.0000000000000000  2.0000000000000000 
    3.0000000000000000  4.0000000000000000 

    3.0000000000000000  4.0000000000000000 
    1.0000000000000000  2.0000000000000000 

---

Или, если вы действительно хотели работать с матрицами 3х3, то ошибка в линии C=T(2:1:-1, :) , Это должно быть C=T(2:0:-1, :).

program main 
    implicit none 

    double precision, dimension(:, :), allocatable :: t, c 
    integer :: i 

    allocate (t(0:2, 0:2)) 
    allocate (c(0:2, 0:2)) 

    t = reshape([1, 4, 7, 2, 5, 8, 3, 6, 9], shape(t)) 
    do i = 0, 2 
    write (*, *) t(i, :) 
    end do 
    write (*, *) "" 

    c = t(2:0:-1, :) 
    do i = 0, 2 
    write (*, *) c(i, :) 
    end do 
end program main 

Выход:

1.0000000000000000  2.0000000000000000  3.0000000000000000 
    4.0000000000000000  5.0000000000000000  6.0000000000000000 
    7.0000000000000000  8.0000000000000000  9.0000000000000000 

    7.0000000000000000  8.0000000000000000  9.0000000000000000 
    4.0000000000000000  5.0000000000000000  6.0000000000000000 
    1.0000000000000000  2.0000000000000000  3.0000000000000000 

---

быть осторожным с подсчета элементов массивов. Off-by-one errors может быть довольно сложно отлаживать, поэтому лучше всегда начинать отсчет с 0 или всегда с 1. И чтобы быть в безопасности, всегда переходите к массивам с помощью lbound и ubound intrinsics, вместо того чтобы использовать явные границы, как это делается выше:

do i = lbound(t, dim=1), ubound(t, dim=1) 
    write (*, *) t(i, :) 
    end do 

Answer 2

Вы назначаете 3 x 3 массива (диапазоны индексов 0 - 2 включительно). Вы присваиваете значения только четырем из девяти элементов массива T, а затем назначаете 2 x 3 среза этого массива C. Это неверно, потому что выражение массива в правой части оператора присваивания имеет другую форму от той, что находится слева.

Кроме того, ваш выбор элементов массива, чтобы писать противоречия, продолжает путаницу в отношении размеров задействованных массивов. Если вы выберете T с размерами 0: 2, 0: 2, а затем переверните его по вертикали, то элемент результата, соответствующий T(2,2), будет C(0,2).

Существует несколько возможных способов исправить код. Среди более вероятно:

• Если вы хотите продолжить с размерами вы сейчас используете, то выражение для перевернутого массива будет T(2:0:-1, :).

• Если вы хотите 2 х 2 массива с индексом в диапазоне 1 - 2, включительно, как это было бы в соответствии с C=T(2:1:-1, :), а затем выделить массивы соответствующим образом (например, allocate(T(2, 2))).