I have written a quick sort routine to inplace sort an array in descending order:
module sort contains recursive subroutine qsort_self(array) real(kind=8) :: array(:), temp integer :: length, pivot, i, j i = 0 j = 0 length = 0 pivot = 1 temp = 0 length = size(array) if (length > 1) then i = 2 j = size(array) do while (i <= j) do while (array(j) < array(pivot)) j = j - 1 enddo do while ((array(i) > array(pivot)) .and. (i<=length)) i = i + 1 enddo if (i > j) exit temp = array(j) array(j) = array(i) array(i) = temp i = i + 1 j = j - 1 enddo temp = array(pivot) array(pivot) = array(j) array(j) = temp pivot = j call qsort_self(array(1:pivot-1)) call qsort_self(array(pivot + 1 : length)) endif end subroutine qsort_self end module sort program p use sort implicit none integer :: size_,i real(kind=8), allocatable :: b6(:) size_ = 100 allocate(b6(size_)) do i = 1, size_ b6(i) = real(rand(), 8) enddo print *, "unsorted: ", b6 call qsort_self(b6) print *,"sorted a= ", b6 end program p
It works fine for now, but without
.and. (i<=length) part of code, i run into errors where if array is in ascending order,
i goes out of bound. I checked several online implementations, such as this:
and I believe they suffer from same flaw. Is here any better way of doing it?
I Always want to take first element as pivot because of the array structure.
Errors in the code
array(i) > array(pivot) .and. i <= length
is not valid code. If
i > length you will get an out of bounds access with
If you rewrite it as
i <= length .and. array(i) > array(pivot)
it is still wrong, because there is no short circuiting in Fortran. Or to be more precise: Fortran operators are neither short-circuit nor eager. The language specification allows the compiler to select the method for optimization. In your case the compiler reorders and short circuits apparently.
The only way to write it reliably correctly is unfortunately:
if (i <= length) then if (array(i) > array(pivot)) then ...
A declaration with a number literal like
real(kind=8) is not portable. You might think, that it is 8 bytes and/or double precision, but the actual integer value for different kinds is implementation dependent. It just happens to be the case, that
ifort use the kind value
8 to denote double precision, but on another compiler this might be wrong.
You should always use
integer, parameter :: dp = selected_real_kind(15, 307)
if you want to have a certain range and precision or
use, intrinsic :: iso_fortran_env, only: real64
if you want to have a float with 8 bytes.
(Of course these both will be the same on most architectures today.)
There is no
implicit none in the module. Strictly speaking this is not an error and you declared all variables correctly, but code without
implicit none should be considered faulty.
Major Code improvements
You should always add one of
intent(in), intent(out), intent(inout) to the dummy arguments of your procedures.
Fortran arrays can be declared with arbitrary numerical indices. You implicitly assumed in your code, that they start at 1 (which is the default).
If you want your routine to work with differently indexed arrays, it is necessary to query the upper and lower bounds.
do i = lbound(array, dim=1), ubound(array, dim=1)
This makes it also explicit when you really mean the size, and when the bounds.
What I initially wrote is wrong. If you use assumed-shape arrays, the dummy argument becomes again 1-indexed by default.
Had to learn that myself the hard way. Sorry. :-/
I agree you with you that these <40 lines don’t require comments for the most parts, but you can write it more readable without comments, by defining a
swap subroutine. This would also reduce the clutter of local variables.
If you define a
get_pivot function, it will be easy to change to different pivoting strategies.
You have superfluous assignments to
length in your code.
IMHO you don’t need this variable anyway, because you can insert
size(array) at every appearance. Any decent compiler will do common-subexpression-elimination on these calls.
Where possible I would use
elemental on your procedures.
They are amazing. 😉
I would always make all names in a module
private and export explicitly with
public. On the other hand I would only import used names.
In the long run, you want to have a second argument where one can pass a
pure logical function that compares two elements. Doing so, the user can sort according to his/her constraints.
Thank you for writing
Fortran and not
If you don’t scream at people it is much easier to read your code. 😉
Of course this is opinion based so, whatever I say, stick to the style of your environment. But for example the whitespace around your binary operators was not consistent. An indentation of two spaces is IMHO too short.
I assume that you are from science and you and your peers use python. In this case it is quite easy to stick to the python formatting guidelines in Fortran.
Minor Code improvements
I agree that the code mostly does not require comments,
but at least public functions of a module should get a docstring on how to use them.
size in the program can be made constant.
The upper and lower bound in array slices can be ommited
A(lbound(A, 1) : 5) == A(: 5)
I would not use
p as program name. If you do so, you can’t use it as variable name anymore.
random_number to generate an array of real numbers.
Possible improved version
module sort implicit none private public :: dp, qsort integer, parameter :: dp = selected_real_kind(15, 307) abstract interface logical pure function compare_t(a, b) import :: dp real(dp), intent(in) :: a, b end function end interface contains !> @brief !> Sort array inplace according to comparison function comp. !> !> @details !> The comparison function has to be a pure, logical function !> that compares two elements of array in a strict partial order. !> That means equality has to evaluate to false. pure recursive subroutine qsort(array, comp) real(kind=dp), intent(inout) :: array(:) procedure(compare_t) :: comp integer :: pivot, i, j i = 0 j = 0 pivot = get_pivot(array) if (size(array) > 1) then i = lbound(array, dim=1) j = ubound(array, dim=1) do while (i <= j) do while (comp(array(i), array(pivot))) i = i + 1 end do do while (comp(array(pivot), array(j))) j = j - 1 end do if (i >= j) exit call swap(array(i), array(j)) i = i + 1 j = j - 1 end do call swap(array(pivot), array(j)) call qsort(array(: j - 1), comp) call qsort(array(j + 1 : ), comp) end if end subroutine qsort pure subroutine swap(a, b) real(dp), intent(inout) :: a, b real(dp) :: temp temp = a a = b b = temp end subroutine pure function get_pivot(array) result(res) real(dp), intent(in) :: array(:) integer :: res res = lbound(array, dim=1) end function end module sort program test_qsort_procedures use sort, only: dp, qsort implicit none integer, parameter :: size_ = 100 real(kind=dp), allocatable :: b6(:) allocate(b6(size_)) call random_number(b6) print *, "unsorted: ", b6 call qsort(b6, increasing) print *,"increasing a= ", b6 call qsort(b6, decreasing) print *,"decreasing a= ", b6 contains logical pure function increasing(a, b) real(dp), intent(in) :: a, b increasing = a < b end function logical pure function decreasing(a, b) real(dp), intent(in) :: a, b decreasing = a > b end function end program test_qsort_procedures