# RANDOM PERMUTATION OF A LIST

One simple way to randomly scramble a list of any type is to create a random permutation of all the index values of the array and then access the original list elements using that list of indices. The list itself can be re-ordered very succintly using array syntax.

Here is a simple example that, given a list size

1. creates an INTEGER array of the specified size N
2. populates it with the values from 1 to N
3. randomly switches values in the array to randomize it
4. returns the newly created array for use as indices

The resulting random permutation of the indices can then be used to access essentially any type of list in random order.

## NAME

scramble(3f) - return an integer array prepopulated with the values 1 to size(array) in random order

## SYNOPSIS

function scramble( number_of_values )
integer,intent(in) :: number_of_values

## DESCRIPTION

Return an integer array of the size specified populated with the numbers 1 to number\of\_values_ in random order.

## OPTIONS

number_of_values
size of integer array to create

## RETURNS

scramble
Integer array filled with integers 1 to N in random order

## EXAMPLE

Sample program and associated function shows a function returning an array, basic random number generation, and using the function results in an array syntax expression.

    program demo_scramble
use M_scramble, only : scramble
implicit none

!@(#) print a list of character values in random order several times

! here is a list of character values to use for an example
! it could be a list of any type
character(len=*),parameter :: list(*)=[character(len=5) :: &
'one','two','three','four','five','six','seven','eight','nine','ten']
integer  :: I

do i = 1,8 ! use random values as indices to randomize array
write(*,'(*(a,1x))') list(scramble(size(list)))
enddo

end program demo_scramble

### Example output

ten   six   eight one   four  nine  two   five  three seven
three five  ten   nine  one   four  six   seven two   eight
four  eight ten   two   seven nine  six   three one   five
three one   nine  seven ten   five  two   six   eight four
two   seven nine  one   four  three eight ten   five  six
three one   nine  six   ten   five  eight two   four  seven
four  five  six   eight one   ten   three nine  seven two
three nine  four  two   one   seven ten   five  six   eight

module M_scramble
implicit none
private
public scramble

contains

function scramble( number_of_values ) result(array)

!@(#) M_random::scramble(3f): return integer array of random values 1 to N.
integer,intent(in)    :: number_of_values
integer,allocatable   :: array(:)
integer               :: i, j, k, m, n
integer               :: temp
real                  :: u

array=[(i,i=1,number_of_values)]

! The intrinsic RANDOM_NUMBER(3f) returns a real number (or an array
! of such) from the uniform distribution over the interval [0,1). (ie.
! it includes 0 but not 1.).
!
! To have a discrete uniform distribution on
! the integers {n, n+1, ..., m-1, m} carve the continuous distribution
! up into m+1-n equal sized chunks, mapping each chunk to an integer.
!
! One way is:
!   call random_number(u)
!   j = n + FLOOR((m+1-n)*u)  ! choose one from m-n+1 integers

n=1
m=number_of_values
do k=1,2
do i=1,m
call random_number(u)
j = n + FLOOR((m+1-n)*u)
! switch values
temp=array(j)
array(j)=array(i)
array(i)=temp
enddo
enddo

end function scramble

category: code