pm_distUnif::xoshiro256ssw_type Type Reference

This is the derived type for declaring and generating objects of type xoshiro256ssw_type containing a unique instance of a Xoshiro256** random number generator (RNG). More...

Inheritance diagram for pm_distUnif::xoshiro256ssw_type:

Collaboration diagram for pm_distUnif::xoshiro256ssw_type:

Additional Inherited Members
Public Attributes inherited from pm_distUnif::xoshiro256ss_type
integer(IK64), dimension(xoshiro256ssStateSize)	state = [ -5952639272145821898_IK64 , -2790978430781836137_IK64 , -4872796757339724681_IK64 , -6638731986642513151_IK64 ]
	The vector of size xoshiro256ssStateSize of type integer of kind IK64, containing the most recent RNG state. More...
integer(IK64)	stream
	The scalar of type integer of kind IK64, containing the most recently generated random 64-bit stream. More...

Detailed Description

This is the derived type for declaring and generating objects of type xoshiro256ssw_type containing a unique instance of a Xoshiro256** random number generator (RNG).

See also the documentation of xoshiro256ssw_typer for information on the constructor of this type.

Xorshift random number generators, also called shift-register generators, are a class of pseudorandom number generators that were invented by George Marsaglia.
They are a subset of linear-feedback shift registers (LFSRs) which allow a particularly efficient implementation in software without the excessive use of sparse polynomials.
They generate the next number in their sequence by repeatedly taking the Exclusive OR (XOR) of a number with a bit-shifted version of itself.
This makes execution extremely efficient on modern computer architectures, although it does not benefit efficiency in a hardware implementation.
Like all LFSRs, the parameters have to be chosen very carefully in order to achieve a long period.

The xoshiro256** RNG implemented in this derived type is a subclass of Xorshift RNGs developed by David Blackman and Sebastiano Vigna.
It is a 64-bit RNG that uses a carefully constructed linear transformation combined with shifts and rotations.
This produces a computationally fast RNG with claimed excellent statistical qualities.
Xoshiro256 has a period of \(2^{256} - 1\) and and supports jumping the sequence in increments of \(2^128\) and \(2^192\).
This allows the creation of many non-overlapping RNG subsequences for parallel applications.

xoshiro256** random seed The xoshiro256** state is determined by a vector of size xoshiro256ssStateSize of type integer of kind IK64.
The RNG seed of xoshiro256** in this module is initialized based on either a user-specified scalar initial seed value or an internal processor-dependent value based on the system clock.
In either case, the seed is used as an input for another simple random number generator splitMix64 and the output of this RNG is used as the initial state of xoshiro256**.

Parallel applications xoshiro256** has a period of \(2^{256} - 1\) and and supports jumping the sequence in increments of \(2^128\) and \(2^192\).
This allows the creation of many non-overlapping RNG subsequences for parallel applications.
xoshiro256** can be used in parallel applications by passing the imageID of the current processor to the RNG constructor.
By default, the RNG constructor makes jumps of size 2**128 in the RRNG sequence to initialize subsequent RNGs on different processors.
While such jump size is more than enough for any practical applications in modern days, the future galactic humans can request longer jumps of size 2**192 by passing the non-default longer jump vector xoshiro256ssJump192 to the constructor of the RNG.
In either case, all RNGs on different processors must be initialized with the same original seed and jump vector (but with different processor IDs set by the imageID argument to the RNG constructor) to ensure that the individual RNG sequences on different processors do not overlap.

Usage instructions This derived type contains only the most recently updated state and random bit stream of the RNG.
To generate random values of arbitrary intrinsic kinds (character, integer, logical, complex, real) the user must,

1. declare an object of type xoshiro256ssw_type and initialize the object via the type constructor xoshiro256ssw_typer (see below for the possible calling interfaces),
2. pass the generated RNG instance to the desired random number generating routines,
   1. getUnifRand,
   2. setUnifRand,
   to generate the desired scalar or sequence of random values.
   

Parameters

[in]	seed	: The input scalar of type integer of kind IK64, containing an integer that serves as the starting point to generate the full deterministic RNG seed. Specify this input argument if you wish to make random simulations reproducible and deterministic, even between multiple independent runs of the program compiled by the same compiler. (optional. If missing, it is set to a processor-dependent value based on the current date and time.)
[in]	imageID	: The input positive scalar integer of default kind IK containing the ID of the current image/thread/process. This can be, The Coarray image ID as returned by Fortran intrinsic this_image() within a global team of Coarray images. The MPI rank of the processor (plus one) as returned by the MPI library intrinsic mpi_comm_rank(). The OpenMP thread number as returned by the OpenMP library intrinsic omp_get_thread_num(). Any (positive) integer that uniquely identifies the current processor from other processes. The image/process/thread ID can be readily obtained by calling getImageID. This number will be used to set the RNG seed uniquely on each processor. (optional. If missing, the RNG seed will be set as if it is called in a serial application (or called on the first image).)
[in]	jump	: The input vector of size xoshiro256ssStateSize of type integer of kind IK64, whose value sets the jump size of the random number generator. It can be, xoshiro256ssJump128, corresponding to a jump size of imageID * 2**128. This jump can be used to generate up to 2**128 unique RNG sequences in parallel, each with length 2**128. xoshiro256ssJump192, corresponding to a jump size of imageID * 2**192. This jump can be used to generate up to 2**64 unique RNG sequences in parallel, each with length 2**192. (optional. default = xoshiro256ssJump128)

Returns

rng : The output scalar object (or array of objects, of the same rank and shape as the input array-like arguments) of type xoshiro256ssw_type containing an instance of a splitmix64 random number generator.

Possible calling interfaces ⛓

use pm_kind, only: IK
use pm_distUnif, only: xoshiro256ssw_type
type(xoshiro256ssw_type) :: rng
 
rng = xoshiro256ssw_type(seed = seed, imageID = imageID, jump = jump)
rand = getUnifRand(rng, rand, lb, ub)
call setUnifRand(rng, rand, lb, ub)
call setUnifRand(rng, rand)

Warning

The condition 0 < imageID must hold for the corresponding input arguments.
This condition is verified only if the library is built with the preprocessor macro CHECK_ENABLED=1.

Although the components of this derived type are public, they are theoretically protected.
The end users must not manipulate the component values at any stages of the random number generation.

Note

Without initializing objects of this derived type, the generated RNGs will always be deterministic, always yielding identical sequences.

See also

rngf
isHead
getUnifCDF
getUnifRand
setUnifRand
getUnifRandState
setUnifRandState
rngu_type
rngf_type
splitmix64_type
xoshiro256ssw_type
getUnifRandStateSize

Example usage ⛓

program example
 
    use pm_kind, only: SK, IK, LK
    use pm_err, only: setAsserted
    use pm_io, only: display_type
    use pm_io, only: getFormat
    use pm_distUnif, only: getUnifRand
    use pm_distUnif, only: setUnifRand
    use pm_distUnif, only: xoshiro256ssw_type
    use pm_io, only: getErrTableWrite
 
    implicit none
 
    integer :: itry, ntry = 5
    type(xoshiro256ssw_type) :: rng
    type(display_type) :: disp
 
    disp = display_type(file = "main.out.F90")
 
    call disp%skip()
    call disp%show("rng = xoshiro256ssw_type()")
                    rng = xoshiro256ssw_type()
 
    block
        use pm_kind, only: IKD
        integer :: rand, lb, ub
        do itry = 1, ntry
        call disp%show("lb = -3_IKD; ub = 5_IKD")
                        lb = -3_IKD; ub = 5_IKD
        call disp%show("rand = getUnifRand(rng, lb, ub)")
                        rand = getUnifRand(rng, lb, ub)
        call disp%show("[lb, rand, ub]")
        call disp%show( [lb, rand, ub] )
        call disp%show(.and."call setAsserted(lb <= rand  rand <= ub)")
                        call setAsserted(lb <= rand .and. rand <= ub)
        end do
        call disp%skip()
    end block
 
    block
        use pm_kind, only: IKG => IKS
        integer(IKG) :: rand, lb, ub
        do itry = 1, ntry
        call disp%show("digits(0_IKG)")
        call disp%show( digits(0_IKG) )
        call disp%show("lb = -3_IKG; ub = 5_IKG")
                        lb = -3_IKG; ub = 5_IKG
        call disp%show("rand = getUnifRand(rng, lb, ub)")
                        rand = getUnifRand(rng, lb, ub)
        call disp%show("[lb, rand, ub]")
        call disp%show( [lb, rand, ub] )
        call disp%show(.and."call setAsserted(lb <= rand  rand <= ub)")
                        call setAsserted(lb <= rand .and. rand <= ub)
        end do
        call disp%skip()
    end block
 
    block
        use pm_kind, only: IKG => IKL
        integer(IKG) :: rand, lb, ub
        do itry = 1, ntry
        call disp%show("digits(0_IKG)")
        call disp%show( digits(0_IKG) )
        call disp%show("lb = -huge(0_IKG); ub = huge(0_IKG) / 2_IKG")
                        lb = -huge(0_IKG); ub = huge(0_IKG) / 2_IKG
        call disp%show("rand = getUnifRand(rng, lb, ub)")
                        rand = getUnifRand(rng, lb, ub)
        call disp%show("[lb, rand, ub]")
        call disp%show( [lb, rand, ub] )
        call disp%show(.and."call setAsserted(lb <= rand  rand <= ub)")
                        call setAsserted(lb <= rand .and. rand <= ub)
        end do
        call disp%skip()
    end block
 
    block
        character(2) :: rand, lb, ub
        do itry = 1, ntry
        call disp%show("lb = 'ai'; ub = 'by'")
                        lb = 'ai'; ub = 'by'
        call disp%show("rand = getUnifRand(rng, lb, ub)")
                        rand = getUnifRand(rng, lb, ub)
        call disp%show("[lb, rand, ub]")
        call disp%show( [lb, rand, ub] )
        call disp%show(.and."call setAsserted(lb <= rand  rand <= ub)")
                        call setAsserted(lb <= rand .and. rand <= ub)
        end do
        call disp%skip()
    end block
 
    block
        use pm_logicalCompare, only: operator(<=)
        logical :: rand, lb, ub
        do itry = 1, 10
        call disp%show("lb = .false.; ub = .true.")
                        lb = .false.; ub = .true.
        call disp%show("rand = getUnifRand(rng, lb, ub)")
                        rand = getUnifRand(rng, lb, ub)
        call disp%show("[lb, rand, ub]")
        call disp%show( [lb, rand, ub] )
        call disp%show(.and."call setAsserted(lb <= rand  rand <= ub)")
                        call setAsserted(lb <= rand .and. rand <= ub)
        end do
        call disp%skip()
    end block
 
    block
        use pm_complexCompareAll, only: operator(<=), operator(<)
        complex :: rand, lb, ub
        do itry = 1, ntry
        call disp%show("lb = (-1., +1.); ub = (1., +2.)")
                        lb = (-1., +1.); ub = (1., +2.)
        call disp%show("rand = getUnifRand(rng, lb, ub)")
                        rand = getUnifRand(rng, lb, ub)
        call disp%show("[lb, rand, ub]")
        call disp%show( [lb, rand, ub] )
        call disp%show(.and."call setAsserted(lb <= rand  rand < ub)")
                        call setAsserted(lb <= rand .and. rand < ub)
        end do
        call disp%skip()
    end block
 
    block
        use pm_kind, only: RKG => RKH
        real(RKG) :: rand, lb, ub
        call disp%show("lb = 2._RKG; ub = lb + spacing(lb)")
                        lb = 2._RKG; ub = lb + spacing(lb)
        do itry = 1, ntry
        call disp%show("call setUnifRand(rng, rand, lb, ub)")
                        call setUnifRand(rng, rand, lb, ub)
        call disp%show("[lb, rand, ub], format = getFormat(width = 42_IK, ndigit = 35_IK)")
        call disp%show( [lb, rand, ub], format = getFormat(width = 42_IK, ndigit = 35_IK) )
        call disp%show(.and."call setAsserted(lb <= rand  rand < ub)")
                        call setAsserted(lb <= rand .and. rand < ub)
        end do
        call disp%skip()
    end block
 
    block
        real :: rand, lb, ub
        do itry = 1, ntry
        call disp%show("lb = -3.; ub = 5.")
                        lb = -3.; ub = 5.
        call disp%show("rand = getUnifRand(rng, lb, ub)")
                        rand = getUnifRand(rng, lb, ub)
        call disp%show("[lb, rand, ub]")
        call disp%show( [lb, rand, ub] )
        call disp%show(.and."call setAsserted(lb <= rand  rand < ub)")
                        call setAsserted(lb <= rand .and. rand < ub)
        end do
        call disp%skip()
    end block
 
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    ! Output an example rand array for visualization.
    !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 
    block
        integer :: rand(5000)
        call setUnifRand(rng, rand, -2, 3)
        if (0 /= getErrTableWrite(SK_"xoshiro256ssw_type.IK.txt", rand)) error stop "Table writing failed."
    end block
 
    block
        complex :: rand(5000)
        call setUnifRand(rng, rand, (-2., +2.), (3., 5.))
        if (0 /= getErrTableWrite(SK_"xoshiro256ssw_type.CK.txt", rand)) error stop "Table writing failed."
    end block
 
    block
        real :: rand(5000)
        call setUnifRand(rng, rand)
        if (0 /= getErrTableWrite(SK_"xoshiro256ssw_type.RK.txt", rand)) error stop "Table writing failed."
    end block
 
end program example

Example Unix compile command via Intel ifort compiler ⛓

#!/usr/bin/env sh
rm main.exe
ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓

del main.exe
set PATH=..\..\..\lib;%PATH%
ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe
main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓

#!/usr/bin/env sh
rm main.exe
gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe
./main.exe

Example output ⛓

 
rng = xoshiro256ssw_type()
lb = -3_IKD; ub = 5_IKD
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +4, +5
call setAsserted(lb <= rand .and. rand <= ub)
lb = -3_IKD; ub = 5_IKD
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +4, +5
call setAsserted(lb <= rand .and. rand <= ub)
lb = -3_IKD; ub = 5_IKD
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, -2, +5
call setAsserted(lb <= rand .and. rand <= ub)
lb = -3_IKD; ub = 5_IKD
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +1, +5
call setAsserted(lb <= rand .and. rand <= ub)
lb = -3_IKD; ub = 5_IKD
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +0, +5
call setAsserted(lb <= rand .and. rand <= ub)
 
digits(0_IKG)
+31
lb = -3_IKG; ub = 5_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +3, +5
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+31
lb = -3_IKG; ub = 5_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, -1, +5
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+31
lb = -3_IKG; ub = 5_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +3, +5
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+31
lb = -3_IKG; ub = 5_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +1, +5
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+31
lb = -3_IKG; ub = 5_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, +4, +5
call setAsserted(lb <= rand .and. rand <= ub)
 
digits(0_IKG)
+7
lb = -huge(0_IKG); ub = huge(0_IKG) / 2_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-127, +58, +63
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+7
lb = -huge(0_IKG); ub = huge(0_IKG) / 2_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-127, +6, +63
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+7
lb = -huge(0_IKG); ub = huge(0_IKG) / 2_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-127, +39, +63
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+7
lb = -huge(0_IKG); ub = huge(0_IKG) / 2_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-127, +49, +63
call setAsserted(lb <= rand .and. rand <= ub)
digits(0_IKG)
+7
lb = -huge(0_IKG); ub = huge(0_IKG) / 2_IKG
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-127, +32, +63
call setAsserted(lb <= rand .and. rand <= ub)
 
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, aw, by
call setAsserted(lb <= rand .and. rand <= ub)
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, bt, by
call setAsserted(lb <= rand .and. rand <= ub)
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, al, by
call setAsserted(lb <= rand .and. rand <= ub)
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, ao, by
call setAsserted(lb <= rand .and. rand <= ub)
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, ao, by
call setAsserted(lb <= rand .and. rand <= ub)
 
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, F, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, T, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, T, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, T, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, T, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, T, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, T, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, F, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, T, T
call setAsserted(lb <= rand .and. rand <= ub)
lb = .false.; ub = .true.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
F, F, T
call setAsserted(lb <= rand .and. rand <= ub)
 
lb = (-1., +1.); ub = (1., +2.)
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
(-1.00000000, +1.00000000), (-0.293040752, +1.79170799), (+1.00000000, +2.00000000)
call setAsserted(lb <= rand .and. rand < ub)
lb = (-1., +1.); ub = (1., +2.)
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
(-1.00000000, +1.00000000), (+0.773920536, +1.06976700), (+1.00000000, +2.00000000)
call setAsserted(lb <= rand .and. rand < ub)
lb = (-1., +1.); ub = (1., +2.)
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
(-1.00000000, +1.00000000), (+0.165594220, +1.48798347), (+1.00000000, +2.00000000)
call setAsserted(lb <= rand .and. rand < ub)
lb = (-1., +1.); ub = (1., +2.)
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
(-1.00000000, +1.00000000), (-0.987706423, +1.35621929), (+1.00000000, +2.00000000)
call setAsserted(lb <= rand .and. rand < ub)
lb = (-1., +1.); ub = (1., +2.)
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
(-1.00000000, +1.00000000), (+0.600876570, +1.62963498), (+1.00000000, +2.00000000)
call setAsserted(lb <= rand .and. rand < ub)
 
lb = 2._RKG; ub = lb + spacing(lb)
call setUnifRand(rng, rand, lb, ub)
[lb, rand, ub], format = getFormat(width = 42_IK, ndigit = 35_IK)
  2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000004    
call setAsserted(lb <= rand .and. rand < ub)
call setUnifRand(rng, rand, lb, ub)
[lb, rand, ub], format = getFormat(width = 42_IK, ndigit = 35_IK)
  2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000004    
call setAsserted(lb <= rand .and. rand < ub)
call setUnifRand(rng, rand, lb, ub)
[lb, rand, ub], format = getFormat(width = 42_IK, ndigit = 35_IK)
  2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000004    
call setAsserted(lb <= rand .and. rand < ub)
call setUnifRand(rng, rand, lb, ub)
[lb, rand, ub], format = getFormat(width = 42_IK, ndigit = 35_IK)
  2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000004    
call setAsserted(lb <= rand .and. rand < ub)
call setUnifRand(rng, rand, lb, ub)
[lb, rand, ub], format = getFormat(width = 42_IK, ndigit = 35_IK)
  2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000000    ,   2.0000000000000000000000000000000004    
call setAsserted(lb <= rand .and. rand < ub)
 
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, -0.187926292E-1, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, +1.05302811, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, +0.934871674, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, -1.62515020, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, -2.47473049, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
 
 

Postprocessing of the example output ⛓

#!/usr/bin/env python
 
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
import glob
import sys
 
linewidth = 2
fontsize = 17
 
marker ={ "CK" : "-"
        , "IK" : "."
        , "RK" : "-"
        }
xlab =  { "CK" : "Uniform Random Value ( real/imaginary components )"
        , "IK" : "Uniform Random Value ( integer-valued )"
        , "RK" : "Uniform Random Value ( real-valued )"
        }
#legends =   [ r"$lb = 0., ub = 1.$"
#            , r"$lb = 0., ub = 1.$"
#            , r"$lb = 0., ub = 1.$"
#            ]
 
for kind in ["IK", "CK", "RK"]:
 
    pattern = "*." + kind + ".txt"
    fileList = glob.glob(pattern)
    if len(fileList) == 1:
 
        df = pd.read_csv(fileList[0], delimiter = ",", header = None)
 
        fig = plt.figure(figsize = 1.25 * np.array([6.4, 4.8]), dpi = 200)
        ax = plt.subplot()
 
        for j in range(len(df.values[0,:])):
            if kind == "CK":
                plt.hist( df.values[:,j]
                        , histtype = "stepfilled"
                        , alpha = 0.5
                        , bins = 75
                        )
            else:
                plt.hist( df.values[:,j]
                        , histtype = "stepfilled"
                        , alpha = 0.5
                        , bins = 75
                        )
               #ax.legend   ( legends
               #            , fontsize = fontsize
               #            )
        plt.xticks(fontsize = fontsize - 2)
        plt.yticks(fontsize = fontsize - 2)
        ax.set_xlabel(xlab[kind], fontsize = 17)
        ax.set_ylabel("Count", fontsize = 17)
        ax.set_title("Histograms of {} Uniform random values".format(len(df.values[:, 0])), fontsize = 17)
 
        plt.grid(visible = True, which = "both", axis = "both", color = "0.85", linestyle = "-")
        ax.tick_params(axis = "y", which = "minor")
        ax.tick_params(axis = "x", which = "minor")
 
        plt.savefig(fileList[0].replace(".txt",".png"))
 
    elif len(fileList) > 1:
 
        sys.exit("Ambiguous file list exists.")

Visualization of the example output ⛓

Test:

test_pm_distUnif

Todo:

High Priority: An illustration of the distribution of the probability of individual bits being 0 or 1 in the mantissa of real-valued random numbers and integer random numbers must be added to the example.

Final Remarks ⛓

---

If you believe this algorithm or its documentation can be improved, we appreciate your contribution and help to edit this page's documentation and source file on GitHub.
For details on the naming abbreviations, see this page.
For details on the naming conventions, see this page.
This software is distributed under the MIT license with additional terms outlined below.

1. If you use any parts or concepts from this library to any extent, please acknowledge the usage by citing the relevant publications of the ParaMonte library.
   
2. If you regenerate any parts/ideas from this library in a programming environment other than those currently supported by this ParaMonte library (i.e., other than C, C++, Fortran, MATLAB, Python, R), please also ask the end users to cite this original ParaMonte library.
   

This software is available to the public under a highly permissive license.
Help us justify its continued development and maintenance by acknowledging its benefit to society, distributing it, and contributing to it.

Copyright

Computational Data Science Lab

Author:

Fatemeh Bagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX

Definition at line 3154 of file pm_distUnif.F90.

---

The documentation for this type was generated from the following file:

• src/fortran/main/pm_distUnif.F90