Errors in the code
This piece
array(i) > array(pivot) .and. i <= length
is not valid code. If i > length you will get an out of bounds access with array(i).
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 gfortran and 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 pure and elemental on your procedures.
They are amazing. ;-)
Architecture
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.
Formatting
Thank you for writing Fortran and not FORTRAN code.
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.
There is 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
