pm_distUnif::splitmix64_type Type Reference

This is the derived type for declaring and generating objects of type splitmix64_type containing a unique instance of an splitmix64 random number generator (RNG). More...

Inheritance diagram for pm_distUnif::splitmix64_type:

Collaboration diagram for pm_distUnif::splitmix64_type:

Public Attributes
integer(IK64)	stream
	The scalar of type integer of kind IK64, containing the most recently generated random 64-bit stream. More...
integer(IK64)	state = 324108011427370141_IK64
	The scalar of type integer of kind IK64, containing the most recent RNG state. More...

Detailed Description

This is the derived type for declaring and generating objects of type splitmix64_type containing a unique instance of an splitmix64 random number generator (RNG).

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

Splitmix64 is a pseudo-random number generator algorithm that originated from the Java programming language and is used in many other programming languages.
It is a fairly simple algorithm that is fast but unsuitable for cryptographic purposes and comparable tasks.
The Splitmix64 algorithm is frequently used to calculate random initial states (seed) of other more complex pseudo-random number generators.
The conventional splitmix64 holds one 64bit state (seed) variable and returns 64bits of random binary data upon subsequent calls.
Splitmix64 is comparatively fast; It requires only 9 64-bit arithmetic/logical operations per 64 bits of random binary stream generation.
A conventional linear RNG provides a generate method that returns one pseudorandom value and updates the state of the RNG.
But the splitable RNG also has a second operation, split, that replaces the original RNG with two (seemingly) independent RNG.
This is done by creating and returning a new such RNG and updating the state of the original object.

Applications

Splitable RNG make it easy to organize the use of pseudorandom numbers in multithreaded programs structured using forkjoin parallelism.
No locking or synchronization is required (other than the usual memory fence immediately after RNG creation).
Because the generate method has no loops or conditionals, it is also suitable for SIMD or GPU implementation.

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 splitmix64_type and initialize the object via the type constructor splitmix64_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 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).)

Returns

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

Possible calling interfaces ⛓

use pm_kind, only: IK
use pm_distUnif, only: splitmix64_type
type(splitmix64_type) :: rng
 
rng = splitmix64_type(seed = seed, imageID = imageID)
print *, rng%state   ! The current RNG state.
print *, rng%stream  ! The current 64bit integer random number.
!

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 user must not change the values of the components of an object of type splitmix64_type at anytime during the random value generation.

The Splitmix64 algorithm is not necessarily the best option for generating random values, particularly, for parallel applications.
Use xoshiro256** algorithm instead.

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: splitmix64_type
    use pm_io, only: getErrTableWrite
 
    implicit none
 
    integer :: itry, ntry = 5
    type(splitmix64_type) :: rng
    type(display_type) :: disp
 
    disp = display_type(file = "main.out.F90")
 
    call disp%skip()
    call disp%show("rng = splitmix64_type()")
                    rng = splitmix64_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_"splitmix64_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_"splitmix64_type.CK.txt", rand)) error stop "Table writing failed."
    end block
 
    block
        real :: rand(5000)
        call setUnifRand(rng, rand)
        if (0 /= getErrTableWrite(SK_"splitmix64_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 = splitmix64_type()
lb = -3_IKD; ub = 5_IKD
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3, -3, +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, +3, +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, +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, -2, +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, +5, +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, -2, +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, +42, +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, +25, +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, +34, +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, +62, +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, +29, +63
call setAsserted(lb <= rand .and. rand <= ub)
 
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, bm, 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, bt, by
call setAsserted(lb <= rand .and. rand <= ub)
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, bj, by
call setAsserted(lb <= rand .and. rand <= ub)
lb = 'ai'; ub = 'by'
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
ai, ai, 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, F, 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 = .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, F, 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.391060114E-1, +1.99536943), (+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.726765394E-1, +1.40922379), (+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.234985471, +1.64044619), (+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.747754216, +1.98392427), (+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.245621204E-1, +1.83962965), (+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, +2.26409197, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, +0.109087944, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, +4.85142183, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, +4.53214359, +5.00000000
call setAsserted(lb <= rand .and. rand < ub)
lb = -3.; ub = 5.
rand = getUnifRand(rng, lb, ub)
[lb, rand, ub]
-3.00000000, +3.14565611, +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:

Amir Shahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas Austin

Definition at line 3593 of file pm_distUnif.F90.

Member Data Documentation

state

integer(IK64) pm_distUnif::splitmix64_type::state = 324108011427370141_IK64

The scalar of type integer of kind IK64, containing the most recent RNG state.

Definition at line 3599 of file pm_distUnif.F90.

stream

integer(IK64) pm_distUnif::splitmix64_type::stream

The scalar of type integer of kind IK64, containing the most recently generated random 64-bit stream.

Definition at line 3596 of file pm_distUnif.F90.

---

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

• src/fortran/main/pm_distUnif.F90