sort_ascending_int Subroutine

private subroutine sort_ascending_int(ivec)

Sorts an integer array ivec in increasing order. Uses a basic recursive quicksort (with insertion sort for partitions with 20 elements).

Arguments

Type IntentOptional Attributes Name
integer, intent(inout), dimension(:) :: ivec

Calls

proc~~sort_ascending_int~~CallsGraph proc~sort_ascending_int numdiff_utilities_module::sort_ascending_int interface~swap numdiff_utilities_module::swap proc~sort_ascending_int->interface~swap proc~swap_int numdiff_utilities_module::swap_int interface~swap->proc~swap_int proc~swap_real numdiff_utilities_module::swap_real interface~swap->proc~swap_real

Called by

proc~~sort_ascending_int~~CalledByGraph proc~sort_ascending_int numdiff_utilities_module::sort_ascending_int interface~sort_ascending numdiff_utilities_module::sort_ascending interface~sort_ascending->proc~sort_ascending_int proc~unique_int numdiff_utilities_module::unique_int proc~unique_int->interface~sort_ascending proc~unique_real numdiff_utilities_module::unique_real proc~unique_real->interface~sort_ascending interface~unique numdiff_utilities_module::unique interface~unique->proc~unique_int interface~unique->proc~unique_real proc~divide_interval numdiff_utilities_module::divide_interval proc~divide_interval->interface~unique proc~put_in_cache numdiff_cache_module::function_cache%put_in_cache proc~put_in_cache->interface~unique proc~compute_function_with_cache numerical_differentiation_module::compute_function_with_cache proc~compute_function_with_cache->proc~put_in_cache proc~compute_sparsity_random_2 numerical_differentiation_module::compute_sparsity_random_2 proc~compute_sparsity_random_2->proc~divide_interval

Source Code

    subroutine sort_ascending_int(ivec)

    implicit none

    integer,dimension(:),intent(inout) :: ivec

    call quicksort(1,size(ivec))

    contains

        recursive subroutine quicksort(ilow,ihigh)

        !! Sort the array

        implicit none

        integer,intent(in) :: ilow
        integer,intent(in) :: ihigh

        integer :: ipivot !! pivot element
        integer :: i      !! counter
        integer :: j      !! counter

        if ( ihigh-ilow<=max_size_for_insertion_sort .and. ihigh>ilow ) then

            ! do insertion sort:
            do i = ilow + 1,ihigh
                do j = i,ilow + 1,-1
                    if ( ivec(j) < ivec(j-1) ) then
                        call swap(ivec(j),ivec(j-1))
                    else
                        exit
                    end if
                end do
            end do

        elseif ( ihigh-ilow>max_size_for_insertion_sort ) then

            ! do the normal quicksort:
            call partition(ilow,ihigh,ipivot)
            call quicksort(ilow,ipivot - 1)
            call quicksort(ipivot + 1,ihigh)

        end if

        end subroutine quicksort

        subroutine partition(ilow,ihigh,ipivot)

        !! Partition the array, based on the
        !! lexical ivecing comparison.

        implicit none

        integer,intent(in)  :: ilow
        integer,intent(in)  :: ihigh
        integer,intent(out) :: ipivot

        integer :: i,ip

        call swap(ivec(ilow),ivec((ilow+ihigh)/2))
        ip = ilow
        do i = ilow + 1, ihigh
            if ( ivec(i) < ivec(ilow) ) then
                ip = ip + 1
                call swap(ivec(ip),ivec(i))
            end if
        end do
        call swap(ivec(ilow),ivec(ip))
        ipivot = ip

        end subroutine partition

    end subroutine sort_ascending_int