Line data Source code
1 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
2 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
3 : !!!! !!!!
4 : !!!! ParaMonte: Parallel Monte Carlo and Machine Learning Library. !!!!
5 : !!!! !!!!
6 : !!!! Copyright (C) 2012-present, The Computational Data Science Lab !!!!
7 : !!!! !!!!
8 : !!!! This file is part of the ParaMonte library. !!!!
9 : !!!! !!!!
10 : !!!! LICENSE !!!!
11 : !!!! !!!!
12 : !!!! https://github.com/cdslaborg/paramonte/blob/main/LICENSE.md !!!!
13 : !!!! !!!!
14 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
15 : !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
16 :
17 : !> \brief
18 : !> This module contains classes and procedures for computing various statistical quantities related to the univariate <b>Uniform distribution</b>.
19 : !>
20 : !> \details
21 : !> Specifically, this module contains routines for computing the following quantities of the univariate <b>Uniform distribution</b>:<br>
22 : !> <ol>
23 : !> <li> the Probability Density Function (**PDF**)
24 : !> <li> the Cumulative Distribution Function (**CDF**)
25 : !> <li> the Random Number Generation from the distribution (**RNG**)
26 : !> <li> the Inverse Cumulative Distribution Function **(ICDF)** or the **Quantile Function**
27 : !> </ol>
28 : !>
29 : !> The **continuous uniform distributions** or **rectangular distributions** are a family of symmetric probability distributions.<br>
30 : !> Such a distribution describes an experiment where there is an arbitrary outcome that lies between certain bounds.<br>
31 : !> The bounds are defined by the parameters, \f$a\f$ and \f$b\f$, which are the minimum and maximum values.<br>
32 : !> The interval can either be closed (i.e., \f$[a, b]\f$) or open (i.e., \f$(a, b)\f$).<br>
33 : !> Therefore, the distribution is often abbreviated as \f$U(a,b)\f$ where \f$U\f$ stands for uniform distribution.<br>
34 : !> The difference between the bounds defines the interval length.<br>
35 : !> All intervals of the same length on the distribution's support are equally probable.<br>
36 : !>
37 : !> \note
38 : !> The Uniform distribution is the maximum entropy probability distribution for a random variable \f$X\f$ under no constraint other than that it is contained in the distribution's support.<br>
39 : !>
40 : !> **Probability density function (PDF)**<br>
41 : !>
42 : !> The **PDF** of the continuous uniform distribution is,
43 : !> \f{equation}{
44 : !> f(x) =
45 : !> \begin{cases}
46 : !> \frac{1}{b - a} & \text{for} a\leq x \leq b ~, \\
47 : !> 0 & \text{for} x < a ~ \text{or} ~ x > b ~.
48 : !> \end{cases}
49 : !> \f}
50 : !>
51 : !> The values of \f$f(x)\f$ at the two boundaries \f$a\f$ and \f$b\f$ are usually unimportant, because they do not alter the value of \f$\int_c^d f(x) dx\f$
52 : !> over any interval \f$[c,d]\f$ nor of \f$\int_a^b x f(x) dx\f$ nor of any higher moment.<br>
53 : !> Sometimes they are chosen to be zero, and sometimes chosen to be \f$\frac{1}{b-a}\f$.<br>
54 : !> The latter is appropriate in the context of estimation by the method of maximum likelihood.<br>
55 : !> In the context of Fourier analysis, one may take the value of \f$f(a)\f$ or \f$f(b)\f$ to be \f$\frac{1}{2(b - a)}\f$
56 : !> because then the inverse transform of many integral transforms of this uniform function will yield back the function itself,
57 : !> rather than a function which is equal *almost everywhere*, i.e., except on a set of points with zero measure.<br>
58 : !> Also, it is consistent with the sign function, which has no such ambiguity.<br>
59 : !> Any probability density function integrates to \f$1\f$.<br>
60 : !> Thus, the PDF of the continuous uniform distribution is graphically portrayed as a rectangle where \f$b − a\f$ is the base length and \f$\frac{1}{b-a}\f$ is the height.<br>
61 : !> As the base length increases, the height (the density at any particular value within the distribution boundaries) decreases.<br>
62 : !> In terms of mean \f$\mu\f$ and variance \f$\sigma^{2}\f$ the probability density function of the continuous uniform distribution is,
63 : !> \f{equation}{
64 : !> f(x) =
65 : !> \begin{cases}
66 : !> \frac{1}{2\sigma\sqrt{3}} & \text{for} -\sigma\sqrt{3} \leq x - \mu \leq \sigma\sqrt{3} ~, \\
67 : !> 0 & \text{otherwise} ~.
68 : !> \end{cases}
69 : !> \f}
70 : !>
71 : !> **Cumulative distribution function (CDF)**<br>
72 : !>
73 : !> The **CDF** of the continuous uniform distribution is,<br>
74 : !> \f{equation}{
75 : !> F(x) =
76 : !> \begin{cases}
77 : !> 0 & \text{for} x < a ~,\\
78 : !> \frac{x - a}{b - a} & \text{for} a\leq x\leq b ~, \\
79 : !> 1 & \text{for} x > b ~.
80 : !> \end{cases}
81 : !> \f}
82 : !>
83 : !> In terms of mean \f$\mu\f$ and variance \f$\sigma^{2}\f$, the cumulative distribution function of the continuous uniform distribution is,
84 : !> \f{equation}{
85 : !> F(x) =
86 : !> \begin{cases}
87 : !> 0 & \text{for} x - \mu < -\sigma\sqrt{3} ~, \\
88 : !> \frac{1}{2}\left(\frac{x - \mu}{\sigma\sqrt{3}} + 1\right) & \text{for} -\sigma\sqrt{3} \leq x - \mu < \sigma\sqrt{3} ~, \\
89 : !> 1 & \text{for} x - \mu \geq \sigma\sqrt{3}
90 : !> \end{cases}
91 : !> \f}
92 : !>
93 : !> \note
94 : !> -# The procedures under the generic interface [getUnifCDF](@ref pm_distUnif::getUnifCDF) of this module
95 : !> are `elemental` functions that accept `optional` arguments of arbitrary ranks.<br>
96 : !> As such, the procedures offer great flexibility in coding.<br>
97 : !> However, the elemental nature of the procedures impacts their runtime performance negatively.<br>
98 : !> See the benchmarks below for more information.<br>
99 : !> -# The procedures under the generic interface [setUnifCDF](@ref pm_distUnif::setUnifCDF)
100 : !> are subroutines that accept a limited range of specific arguments ranks.<br>
101 : !> As such, they offer much better runtime performance compared to [getUnifCDF](@ref pm_distUnif::getUnifCDF)
102 : !> but have significantly less flexibility.<br>
103 : !> -# **Which procedures should I use?**<br>
104 : !> The `elemental` procedures appear to incur no performance penalty with scalar arguments.
105 : !> However, there appears to exist a runtime performance penalty of ~2-3 times more than the rank-specific
106 : !> routines for array arguments, comparable to 10-20 CPU cycles.<br>
107 : !> These penalties are due to the looping that occur in the `elemental` procedures for array arguments.<br>
108 : !> However, this `elemental` performance penalty is likely **insignificant** in most practical cases,
109 : !> unless the `elemental` procedures are to be called on the order of tens of billions of times in a program,
110 : !> in which, case, the over all performance penalty, as of 2022, appears to be on the order of a few minutes or less.<br>
111 : !> -# Note that the following benchmarks represent the worst case scenarios.<br>
112 : !> There may be situations where the compiler could inline the `elemental` procedures
113 : !> and remove the overhead of repeatedly calling the `elemental` function.
114 : !>
115 : !> **Inverse Cumulative distribution function (ICDF) or Quantile Function**<br>
116 : !>
117 : !> The Quantile function of continuous Uniform distribution is given by,
118 : !> \f{equation}{
119 : !> F^{-1}(p) = a + p(b - a) \quad \text{for} 0 < p < 1 ~.
120 : !> \f}
121 : !>
122 : !> In terms of mean \f$\mu\f$ and variance \f$\sigma^{2}\f$, the Quantile function of the continuous uniform distribution is,
123 : !> \f{equation}{
124 : !> F^{-1}(p) = \sigma\sqrt{3} (2p - 1) + \mu \quad \text{for} 0 \leq p \leq 1 ~.
125 : !> \f}
126 : !>
127 : !> **Random Number Generation (RNG)**<br>
128 : !>
129 : !> This module contains two generic functional and subroutine interfaces
130 : !> <ol>
131 : !> <li> [getUnifRand](@ref pm_distUnif::getUnifRand)
132 : !> <li> [setUnifRand](@ref pm_distUnif::setUnifRand)
133 : !> </ol>
134 : !> for generating uniformly distributed random values of all intrinsic types and kinds supported by
135 : !> the Fortran standard and the processor (`character`, `integer`, `logical`, `complex`, `real`).<br>
136 : !> The functional interface is merely a wrapper around the generic subroutine interface.<br>
137 : !>
138 : !> This module also contains four random number generator (RNG) algorithms that can be specified via the corresponding types,
139 : !> <ol>
140 : !> <li> [rngf_type](@ref pm_distUnif::rngf_type) (the default intrinsic Fortran uniform RNG via `random_number()`)
141 : !> <li> [splitmix64_type](@ref pm_distUnif::splitmix64_type)
142 : !> <li> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type)
143 : !> <li> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)
144 : !> </ol>
145 : !>
146 : !> <b>Usage</b><br>
147 : !> <ol>
148 : !> <li> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) is the recommended RNG for all serial and parallel tasks.<br>
149 : !> <li> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) is the recommended RNG for tasks
150 : !> that mostly require `logical` random values, although it can be used for random value generation of any type and kind.<br>
151 : !> <li> [splitmix64_type](@ref pm_distUnif::splitmix64_type) is the recommended RNG for initializing other RNGs
152 : !> or for simple serial tasks, although it can be used for random value generation of any type and kind.<br>
153 : !> <li> The default Fortran RNG [rngf_type](@ref pm_distUnif::rngf_type), although flexible to use and fast,
154 : !> will not generate deterministic results across different compilers.<br>
155 : !> </ol>
156 : !>
157 : !> \benchmarks
158 : !>
159 : !> \benchmark{getUnifCDF_vs_setUnifCDF_D0, The runtime performance of scalar [getUnifCDF](@ref pm_distUnif::getUnifCDF) vs. [setUnifCDF](@ref pm_distUnif::setUnifCDF) without bounds}
160 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0/main.F90
161 : !> \compilefb{getUnifCDF_vs_setUnifCDF_D0}
162 : !> \postprocb{getUnifCDF_vs_setUnifCDF_D0}
163 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0/main.py
164 : !> \visb{getUnifCDF_vs_setUnifCDF_D0}
165 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0/benchmark.getUnifCDF_vs_setUnifCDF_D0.runtime.png width=1000
166 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0/benchmark.getUnifCDF_vs_setUnifCDF_D0.runtime.ratio.png width=1000
167 : !> \moralb{getUnifCDF_vs_setUnifCDF_D0}
168 : !> -# The procedures under the generic interface [getUnifCDF](@ref pm_distUnif::getUnifCDF) are `elemental` functions with `optional` arguments.
169 : !> In the absence of the `optional` arguments, the default values are used, but the associated computations will be redundant.<br>
170 : !> As such, one expects the [getUnifCDF](@ref pm_distUnif::getUnifCDF) to perform less efficiently than
171 : !> the procedures under the generic interface [setUnifCDF](@ref pm_distUnif::setUnifCDF)
172 : !> which are rank-specific and carefully designed to avoid redundant computations.
173 : !>
174 : !> \benchmark{getUnifCDF_vs_setUnifCDF_D1, The runtime performance of array [getUnifCDF](@ref pm_distUnif::getUnifCDF) vs. [setUnifCDF](@ref pm_distUnif::setUnifCDF) without bounds}
175 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1/main.F90
176 : !> \compilefb{getUnifCDF_vs_setUnifCDF_D1}
177 : !> \postprocb{getUnifCDF_vs_setUnifCDF_D1}
178 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1/main.py
179 : !> \visb{getUnifCDF_vs_setUnifCDF_D1}
180 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1/benchmark.getUnifCDF_vs_setUnifCDF_D1.runtime.png width=1000
181 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1/benchmark.getUnifCDF_vs_setUnifCDF_D1.runtime.ratio.png width=1000
182 : !> \moralb{getUnifCDF_vs_setUnifCDF_D1}
183 : !> -# The procedures under the generic interface [getUnifCDF](@ref pm_distUnif::getUnifCDF) are `elemental` functions with `optional` arguments.<br>
184 : !> In the absence of the `optional` arguments, the default values are used, but the associated computations will be redundant.<br>
185 : !> Furthermore, `elemental` functions incur a performance penalty for input array arguments due to internal looping performed
186 : !> by the compiler to call the function repeatedly for different array elements.<br>
187 : !> As such, one expects the [getUnifCDF](@ref pm_distUnif::getUnifCDF) to perform less efficiently than
188 : !> the procedures under the generic interface [setUnifCDF](@ref pm_distUnif::setUnifCDF)
189 : !> which are rank-specific and carefully designed to avoid redundant computations.<br>
190 : !>
191 : !> \benchmark{getUnifCDF_vs_setUnifCDF_D0_D0, The runtime performance of scalar [getUnifCDF](@ref pm_distUnif::getUnifCDF) vs. [setUnifCDF](@ref pm_distUnif::setUnifCDF) with bounds}
192 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0_D0/main.F90
193 : !> \compilefb{getUnifCDF_vs_setUnifCDF_D0_D0}
194 : !> \postprocb{getUnifCDF_vs_setUnifCDF_D0_D0}
195 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0_D0/main.py
196 : !> \visb{getUnifCDF_vs_setUnifCDF_D0_D0}
197 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0_D0/benchmark.getUnifCDF_vs_setUnifCDF_D0_D0.runtime.png width=1000
198 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D0_D0/benchmark.getUnifCDF_vs_setUnifCDF_D0_D0.runtime.ratio.png width=1000
199 : !> \moralb{getUnifCDF_vs_setUnifCDF_D0_D0}
200 : !> -# The procedures under the generic interface [getUnifCDF](@ref pm_distUnif::getUnifCDF) are `elemental` functions with `optional` arguments.<br>
201 : !> In the presence of the `optional` arguments, the user-specified values are used.<br>
202 : !> Therefore, the costs of computations in [getUnifCDF](@ref pm_distUnif::getUnifCDF) are more comparable to
203 : !> the procedures under the generic interface [setUnifCDF](@ref pm_distUnif::setUnifCDF)
204 : !> which are rank-specific and carefully designed to avoid redundant computations.<br>
205 : !>
206 : !> \benchmark{getUnifCDF_vs_setUnifCDF_D1_D0, The runtime performance of array [getUnifCDF](@ref pm_distUnif::getUnifCDF) vs. [setUnifCDF](@ref pm_distUnif::setUnifCDF) with bounds}
207 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1_D0/main.F90
208 : !> \compilefb{getUnifCDF_vs_setUnifCDF_D1_D0}
209 : !> \postprocb{getUnifCDF_vs_setUnifCDF_D1_D0}
210 : !> \include{lineno} benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1_D0/main.py
211 : !> \visb{getUnifCDF_vs_setUnifCDF_D1_D0}
212 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1_D0/benchmark.getUnifCDF_vs_setUnifCDF_D1_D0.runtime.png width=1000
213 : !> \image html benchmark/pm_distUnif/getUnifCDF_vs_setUnifCDF_D1_D0/benchmark.getUnifCDF_vs_setUnifCDF_D1_D0.runtime.ratio.png width=1000
214 : !> \moralb{getUnifCDF_vs_setUnifCDF_D1_D0}
215 : !> -# The procedures under the generic interface [getUnifCDF](@ref pm_distUnif::getUnifCDF) are `elemental` functions with `optional` arguments.<br>
216 : !> In the presence of the `optional` arguments, the user-specified values are used.<br>
217 : !> Although the `elemental` functions incur a performance penalty for input array arguments due to internal looping performed
218 : !> by the compiler to call the function repeatedly for different array elements, the costs of computations in
219 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF) become more comparable to the procedures
220 : !> under the generic interface [setUnifCDF](@ref pm_distUnif::setUnifCDF) which
221 : !> are rank-specific and carefully designed to avoid redundant computations.<br>
222 : !>
223 : !> \benchmark{setUnifRand_vs_random_number, The runtime performance of [setUnifRand](@ref pm_distUnif::setUnifRand) vs. Fortran intrinsic `random_number()`.}
224 : !> \include{lineno} benchmark/pm_distUnif/setUnifRand_vs_random_number/main.F90
225 : !> \compilefb{setUnifRand_vs_random_number}
226 : !> \postprocb{setUnifRand_vs_random_number}
227 : !> \include{lineno} benchmark/pm_distUnif/setUnifRand_vs_random_number/main.py
228 : !> \visb{setUnifRand_vs_random_number}
229 : !> \image html benchmark/pm_distUnif/setUnifRand_vs_random_number/benchmark.setUnifRand_vs_random_number.runtime.png width=1000
230 : !> \image html benchmark/pm_distUnif/setUnifRand_vs_random_number/benchmark.setUnifRand_vs_random_number.runtime.ratio.png width=1000
231 : !> \moralb{setUnifRand_vs_random_number}
232 : !> -# The default RNG in the procedures under the generic interface [setUnifRand](@ref pm_distUnif::setUnifRand)
233 : !> are simply wrappers around the intrinsic random number generator of Fortran `random_number()`.<br>
234 : !> As such, [setUnifRand](@ref pm_distUnif::setUnifRand) for generating random real
235 : !> numbers has \f$\ms{5-10%}\f$ overhead with respect to the intrinsic `random_number()`.<br>
236 : !> Note Fortran does not have `integer`, `logical`, `complex`, or `character` uniform random RNG
237 : !> whereas [setUnifRand](@ref pm_distUnif::setUnifRand) provides a unified API for random numbers of all types.<br>
238 : !> -# The RNGX is an acronym for [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) in the procedures under the generic interface [setUnifRand](@ref pm_distUnif::setUnifRand).<br>
239 : !> This random number generator, although unsafe for cryptographic purposes, is quite competitive and performant, even compared to the intrinsic Fortran compiler RNGs.<br>
240 : !>
241 : !> \benchmark{splitmix64_type_vs_xoshiro256ss_type, The runtime performance of intrinsic `random_number()` vs. [splitmix64_type](@ref pm_distUnif::splitmix64_type) vs. [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type).}
242 : !> \include{lineno} benchmark/pm_distUnif/splitmix64_type_vs_xoshiro256ss_type/main.F90
243 : !> \compilefb{splitmix64_type_vs_xoshiro256ss_type}
244 : !> \postprocb{splitmix64_type_vs_xoshiro256ss_type}
245 : !> \include{lineno} benchmark/pm_distUnif/splitmix64_type_vs_xoshiro256ss_type/main.py
246 : !> \visb{splitmix64_type_vs_xoshiro256ss_type}
247 : !> \image html benchmark/pm_distUnif/splitmix64_type_vs_xoshiro256ss_type/benchmark.splitmix64_type_vs_xoshiro256ss_type.runtime.png width=1000
248 : !> \image html benchmark/pm_distUnif/splitmix64_type_vs_xoshiro256ss_type/benchmark.splitmix64_type_vs_xoshiro256ss_type.runtime.ratio.png width=1000
249 : !> \moralb{splitmix64_type_vs_xoshiro256ss_type}
250 : !> -# The [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) RNG
251 : !> greedily attempts to use as many randomly generated bits as possible in the output random values.<br>
252 : !> -# The [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) RNG
253 : !> takes a wasteful approach of using at least one or more chunks of 64 randomly generated bits in the output random values.<br>
254 : !> -# This fundamental difference between the two RNG types generally leads to faster random logical value generations with
255 : !> the greedy approach, because 64bits chunks translate to 64 logical values without updating the RNG state.<br>
256 : !> -# However, the greedy approach leads to generally slower runtimes for real random value generation.<br>
257 : !> -# Both greedy and wasteful RNGs appear to be much faster than the ParaMonte
258 : !> library wrappers for the implementations offered by \gfortran and \ifort.<br>
259 : !> -# <b>Moral</b>: If your application requires many `logical` random number generation,
260 : !> use the greedy [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) RNG.<br>
261 : !> Conversely, if your application requires a mixture of random number generations of various types and kinds,
262 : !> use the wasteful [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) RNG.
263 : !>
264 : !> \test
265 : !> [test_pm_distUnif](@ref test_pm_distUnif)
266 : !>
267 : !> \finmain
268 : !>
269 : !> \author
270 : !> \AmirShahmoradi, Oct 16, 2009, 11:14 AM, Michigan
271 :
272 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
273 :
274 : module pm_distUnif
275 :
276 : use pm_kind, only: SK, IK, LK, IK64
277 :
278 : implicit none
279 :
280 : !> \cond excluded
281 : !private :: setStateNext, setStateJump
282 : !> \endcond excluded
283 :
284 : character(*, SK), parameter :: MODULE_NAME = "@pm_distUnif"
285 :
286 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
287 :
288 : !> \brief
289 : !> Generate and return the Cumulative Distribution Function (CDF) of a univariate Standard Uniform distribution or a
290 : !> Uniform distribution with the specified support via `lower` and `upper` input arguments at the specified input values.
291 : !>
292 : !> \param[in] x : The input scalar or array of the same shape as other input array arguments, of either <br>
293 : !> <ol>
294 : !> <li> If `X` is `integer`, the discrete Uniform distribution CDF with support `[lower, upper]` will be returned.<br>
295 : !> <li> If `X` is `integer`, the output argument `CDF` must be of type `real` of kind \RK.<br>
296 : !> <li> If `X` is `real`, the continuous Uniform distribution CDF with support `[lower, upper]` will be returned.<br>
297 : !> <li> If `X` is `complex`, the two real and imaginary components of `CDF` will correspond to two independent distributions.<br>
298 : !> </ol>
299 : !> \param[in] lower : The input scalar or array of the same shape as other input array arguments, of the same type and kind as `X`,
300 : !> representing the lower bound of the Uniform distribution.<br>
301 : !> (**optional**, default = `0`. It must be present **if and only if** the input argument `upper` is also present.)
302 : !> \param[in] upper : The input scalar or array of the same shape as other input array arguments, of the same type and kind as `X`,
303 : !> representing the upper bound of the Uniform distribution.<br>
304 : !> (**optional**, default = `1`. It must be present **if and only if** the input argument `lower` is also present.)
305 : !>
306 : !> \return
307 : !> `cdf` : The output scalar or array of the same shape as the input array arguments, of either <br>
308 : !> <ol>
309 : !> <li> type `real` of default kind \RK (if the input value `x` is `integer` of kind \IKALL), or<br>
310 : !> <li> type `complex` of the same kind as `x` (if the input value `x` is of type `complex` of kind \CKALL), <br>
311 : !> <li> type `real` of the same kind as `x` (if the input value `x` is of type `real` of kind \RKALL), <br>
312 : !> </ol>
313 : !> containing the CDF of the specified discrete or continuous Uniform distribution.
314 : !>
315 : !> \interface{getUnifCDF}
316 : !> \code{.F90}
317 : !>
318 : !> use pm_distUnif, only: getUnifCDF
319 : !>
320 : !> cdf = getUnifCDF(x)
321 : !> cdf = getUnifCDF(x, lower, upper)
322 : !>
323 : !> \endcode
324 : !>
325 : !> \warnpure
326 : !>
327 : !> \elemental
328 : !>
329 : !> \see
330 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
331 : !>
332 : !> \example{getUnifCDF}
333 : !> \include{lineno} example/pm_distUnif/getUnifCDF/main.F90
334 : !> \compilef{getUnifCDF}
335 : !> \output{getUnifCDF}
336 : !> \include{lineno} example/pm_distUnif/getUnifCDF/main.out.F90
337 : !> \postproc{getUnifCDF}
338 : !> \include{lineno} example/pm_distUnif/getUnifCDF/main.py
339 : !> \vis{getUnifCDF}
340 : !> \image html pm_distUnif/getUnifCDF/getUnifCDF.IK.png width=700
341 : !> \image html pm_distUnif/getUnifCDF/getUnifCDF.RK.png width=700
342 : !> \image html pm_distUnif/getUnifCDF/getUnifCDF.CK.png width=700
343 : !>
344 : !> \test
345 : !> [test_pm_distUnif](@ref test_pm_distUnif)
346 : !>
347 : !> \todo
348 : !> \pmed This generic interface can be extended to input string arguments to make it compatible with [setUnifRand](@ref pm_distUnif::setUnifRand).
349 : !>
350 : !> \finmain{getUnifCDF}
351 : !>
352 : !> \author
353 : !> \AmirShahmoradi, Oct 16, 2009, 11:14 AM, Michigan
354 :
355 : ! LU
356 :
357 : interface getUnifCDF
358 :
359 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
360 :
361 : #if IK5_ENABLED
362 : PURE elemental module function getUnifCDF_LU_IK5(x, lower, upper) result(cdf)
363 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
364 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_IK5
365 : #endif
366 : use pm_kind, only: IKC => IK5, RKC => RK
367 : integer(IKC), intent(in) :: x
368 : integer(IKC), intent(in) :: lower, upper
369 : real(RKC) :: cdf
370 : end function
371 : #endif
372 :
373 : #if IK4_ENABLED
374 : PURE elemental module function getUnifCDF_LU_IK4(x, lower, upper) result(cdf)
375 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
376 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_IK4
377 : #endif
378 : use pm_kind, only: IKC => IK4, RKC => RK
379 : integer(IKC), intent(in) :: x
380 : integer(IKC), intent(in) :: lower, upper
381 : real(RKC) :: cdf
382 : end function
383 : #endif
384 :
385 : #if IK3_ENABLED
386 : PURE elemental module function getUnifCDF_LU_IK3(x, lower, upper) result(cdf)
387 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
388 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_IK3
389 : #endif
390 : use pm_kind, only: IKC => IK3, RKC => RK
391 : integer(IKC), intent(in) :: x
392 : integer(IKC), intent(in) :: lower, upper
393 : real(RKC) :: cdf
394 : end function
395 : #endif
396 :
397 : #if IK2_ENABLED
398 : PURE elemental module function getUnifCDF_LU_IK2(x, lower, upper) result(cdf)
399 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
400 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_IK2
401 : #endif
402 : use pm_kind, only: IKC => IK2, RKC => RK
403 : integer(IKC), intent(in) :: x
404 : integer(IKC), intent(in) :: lower, upper
405 : real(RKC) :: cdf
406 : end function
407 : #endif
408 :
409 : #if IK1_ENABLED
410 : PURE elemental module function getUnifCDF_LU_IK1(x, lower, upper) result(cdf)
411 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
412 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_IK1
413 : #endif
414 : use pm_kind, only: IKC => IK1, RKC => RK
415 : integer(IKC), intent(in) :: x
416 : integer(IKC), intent(in) :: lower, upper
417 : real(RKC) :: cdf
418 : end function
419 : #endif
420 :
421 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
422 :
423 : #if CK5_ENABLED
424 : PURE elemental module function getUnifCDF_LU_CK5(x, lower, upper) result(cdf)
425 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
426 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_CK5
427 : #endif
428 : use pm_kind, only: CKC => CK5
429 : complex(CKC), intent(in) :: x
430 : complex(CKC), intent(in) :: lower, upper
431 : complex(CKC) :: cdf
432 : end function
433 : #endif
434 :
435 : #if CK4_ENABLED
436 : PURE elemental module function getUnifCDF_LU_CK4(x, lower, upper) result(cdf)
437 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
438 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_CK4
439 : #endif
440 : use pm_kind, only: CKC => CK4
441 : complex(CKC), intent(in) :: x
442 : complex(CKC), intent(in) :: lower, upper
443 : complex(CKC) :: cdf
444 : end function
445 : #endif
446 :
447 : #if CK3_ENABLED
448 : PURE elemental module function getUnifCDF_LU_CK3(x, lower, upper) result(cdf)
449 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
450 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_CK3
451 : #endif
452 : use pm_kind, only: CKC => CK3
453 : complex(CKC), intent(in) :: x
454 : complex(CKC), intent(in) :: lower, upper
455 : complex(CKC) :: cdf
456 : end function
457 : #endif
458 :
459 : #if CK2_ENABLED
460 : PURE elemental module function getUnifCDF_LU_CK2(x, lower, upper) result(cdf)
461 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
462 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_CK2
463 : #endif
464 : use pm_kind, only: CKC => CK2
465 : complex(CKC), intent(in) :: x
466 : complex(CKC), intent(in) :: lower, upper
467 : complex(CKC) :: cdf
468 : end function
469 : #endif
470 :
471 : #if CK1_ENABLED
472 : PURE elemental module function getUnifCDF_LU_CK1(x, lower, upper) result(cdf)
473 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
474 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_CK1
475 : #endif
476 : use pm_kind, only: CKC => CK1
477 : complex(CKC), intent(in) :: x
478 : complex(CKC), intent(in) :: lower, upper
479 : complex(CKC) :: cdf
480 : end function
481 : #endif
482 :
483 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
484 :
485 : #if RK5_ENABLED
486 : PURE elemental module function getUnifCDF_LU_RK5(x, lower, upper) result(cdf)
487 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
488 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_RK5
489 : #endif
490 : use pm_kind, only: RKC => RK5
491 : real(RKC) , intent(in) :: x
492 : real(RKC) , intent(in) :: lower, upper
493 : real(RKC) :: cdf
494 : end function
495 : #endif
496 :
497 : #if RK4_ENABLED
498 : PURE elemental module function getUnifCDF_LU_RK4(x, lower, upper) result(cdf)
499 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
500 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_RK4
501 : #endif
502 : use pm_kind, only: RKC => RK4
503 : real(RKC) , intent(in) :: x
504 : real(RKC) , intent(in) :: lower, upper
505 : real(RKC) :: cdf
506 : end function
507 : #endif
508 :
509 : #if RK3_ENABLED
510 : PURE elemental module function getUnifCDF_LU_RK3(x, lower, upper) result(cdf)
511 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
512 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_RK3
513 : #endif
514 : use pm_kind, only: RKC => RK3
515 : real(RKC) , intent(in) :: x
516 : real(RKC) , intent(in) :: lower, upper
517 : real(RKC) :: cdf
518 : end function
519 : #endif
520 :
521 : #if RK2_ENABLED
522 : PURE elemental module function getUnifCDF_LU_RK2(x, lower, upper) result(cdf)
523 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
524 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_RK2
525 : #endif
526 : use pm_kind, only: RKC => RK2
527 : real(RKC) , intent(in) :: x
528 : real(RKC) , intent(in) :: lower, upper
529 : real(RKC) :: cdf
530 : end function
531 : #endif
532 :
533 : #if RK1_ENABLED
534 : PURE elemental module function getUnifCDF_LU_RK1(x, lower, upper) result(cdf)
535 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
536 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_LU_RK1
537 : #endif
538 : use pm_kind, only: RKC => RK1
539 : real(RKC) , intent(in) :: x
540 : real(RKC) , intent(in) :: lower, upper
541 : real(RKC) :: cdf
542 : end function
543 : #endif
544 :
545 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
546 :
547 : end interface
548 :
549 : ! DD
550 :
551 : interface getUnifCDF
552 :
553 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
554 :
555 : #if IK5_ENABLED
556 : PURE elemental module function getUnifCDF_DD_IK5(x) result(cdf)
557 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
558 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_IK5
559 : #endif
560 : use pm_kind, only: IKC => IK5, RKC => RK
561 : integer(IKC), intent(in) :: x
562 : real(RKC) :: cdf
563 : end function
564 : #endif
565 :
566 : #if IK4_ENABLED
567 : PURE elemental module function getUnifCDF_DD_IK4(x) result(cdf)
568 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
569 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_IK4
570 : #endif
571 : use pm_kind, only: IKC => IK4, RKC => RK
572 : integer(IKC), intent(in) :: x
573 : real(RKC) :: cdf
574 : end function
575 : #endif
576 :
577 : #if IK3_ENABLED
578 : PURE elemental module function getUnifCDF_DD_IK3(x) result(cdf)
579 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
580 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_IK3
581 : #endif
582 : use pm_kind, only: IKC => IK3, RKC => RK
583 : integer(IKC), intent(in) :: x
584 : real(RKC) :: cdf
585 : end function
586 : #endif
587 :
588 : #if IK2_ENABLED
589 : PURE elemental module function getUnifCDF_DD_IK2(x) result(cdf)
590 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
591 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_IK2
592 : #endif
593 : use pm_kind, only: IKC => IK2, RKC => RK
594 : integer(IKC), intent(in) :: x
595 : real(RKC) :: cdf
596 : end function
597 : #endif
598 :
599 : #if IK1_ENABLED
600 : PURE elemental module function getUnifCDF_DD_IK1(x) result(cdf)
601 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
602 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_IK1
603 : #endif
604 : use pm_kind, only: IKC => IK1, RKC => RK
605 : integer(IKC), intent(in) :: x
606 : real(RKC) :: cdf
607 : end function
608 : #endif
609 :
610 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
611 :
612 : #if CK5_ENABLED
613 : PURE elemental module function getUnifCDF_DD_CK5(x) result(cdf)
614 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
615 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_CK5
616 : #endif
617 : use pm_kind, only: CKC => CK5
618 : complex(CKC), intent(in) :: x
619 : complex(CKC) :: cdf
620 : end function
621 : #endif
622 :
623 : #if CK4_ENABLED
624 : PURE elemental module function getUnifCDF_DD_CK4(x) result(cdf)
625 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
626 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_CK4
627 : #endif
628 : use pm_kind, only: CKC => CK4
629 : complex(CKC), intent(in) :: x
630 : complex(CKC) :: cdf
631 : end function
632 : #endif
633 :
634 : #if CK3_ENABLED
635 : PURE elemental module function getUnifCDF_DD_CK3(x) result(cdf)
636 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
637 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_CK3
638 : #endif
639 : use pm_kind, only: CKC => CK3
640 : complex(CKC), intent(in) :: x
641 : complex(CKC) :: cdf
642 : end function
643 : #endif
644 :
645 : #if CK2_ENABLED
646 : PURE elemental module function getUnifCDF_DD_CK2(x) result(cdf)
647 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
648 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_CK2
649 : #endif
650 : use pm_kind, only: CKC => CK2
651 : complex(CKC), intent(in) :: x
652 : complex(CKC) :: cdf
653 : end function
654 : #endif
655 :
656 : #if CK1_ENABLED
657 : PURE elemental module function getUnifCDF_DD_CK1(x) result(cdf)
658 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
659 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_CK1
660 : #endif
661 : use pm_kind, only: CKC => CK1
662 : complex(CKC), intent(in) :: x
663 : complex(CKC) :: cdf
664 : end function
665 : #endif
666 :
667 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
668 :
669 : #if RK5_ENABLED
670 : PURE elemental module function getUnifCDF_DD_RK5(x) result(cdf)
671 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
672 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_RK5
673 : #endif
674 : use pm_kind, only: RKC => RK5
675 : real(RKC) , intent(in) :: x
676 : real(RKC) :: cdf
677 : end function
678 : #endif
679 :
680 : #if RK4_ENABLED
681 : PURE elemental module function getUnifCDF_DD_RK4(x) result(cdf)
682 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
683 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_RK4
684 : #endif
685 : use pm_kind, only: RKC => RK4
686 : real(RKC) , intent(in) :: x
687 : real(RKC) :: cdf
688 : end function
689 : #endif
690 :
691 : #if RK3_ENABLED
692 : PURE elemental module function getUnifCDF_DD_RK3(x) result(cdf)
693 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
694 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_RK3
695 : #endif
696 : use pm_kind, only: RKC => RK3
697 : real(RKC) , intent(in) :: x
698 : real(RKC) :: cdf
699 : end function
700 : #endif
701 :
702 : #if RK2_ENABLED
703 : PURE elemental module function getUnifCDF_DD_RK2(x) result(cdf)
704 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
705 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_RK2
706 : #endif
707 : use pm_kind, only: RKC => RK2
708 : real(RKC) , intent(in) :: x
709 : real(RKC) :: cdf
710 : end function
711 : #endif
712 :
713 : #if RK1_ENABLED
714 : PURE elemental module function getUnifCDF_DD_RK1(x) result(cdf)
715 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
716 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifCDF_DD_RK1
717 : #endif
718 : use pm_kind, only: RKC => RK1
719 : real(RKC) , intent(in) :: x
720 : real(RKC) :: cdf
721 : end function
722 : #endif
723 :
724 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
725 :
726 : end interface
727 :
728 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
729 :
730 : !> \brief
731 : !> Return the Cumulative Distribution Function (CDF) of a univariate Standard Uniform distribution or a Uniform distribution
732 : !> with the specified support via `lower` and `upper` input arguments at the specified input values.
733 : !>
734 : !> \param[out] cdf : The output scalar or `contiguous` array of rank `1` of either <br>
735 : !> <ol>
736 : !> <li> type `complex` of kind \CKALL (if the input value `X` is of type `complex`) or, <br>
737 : !> <li> type `real` of kind \RKALL (if the input value `X` is of type `integer` or `real`), <br>
738 : !> </ol>
739 : !> containing the CDF of the specified discrete or continuous Uniform distribution.
740 : !> \param[in] X : The input scalar or `contiguous` array of the same shape as `cdf`, containing the values at which the CDF must be computed.<br>
741 : !> If `X` is of type `integer`, the CDF of the discrete Uniform distribution with support `[lower, upper]` will be returned.<br>
742 : !> If `X` is of type `integer`, the output argument `CDF` must be of type `real` of kind \RKALL.<br>
743 : !> If `X` is of type `real`, the output argument `CDF` must have the same type, kind, and rank as `X`,
744 : !> and will contain the CDF of the continuous Uniform distribution with support `[lower, upper)`.<br>
745 : !> If `X` is of type `complex`, the output argument `CDF` must have the same type, kind, and rank as `X`.<br>
746 : !> If `X` is of type `complex`, the two real and imaginary components of `CDF` will correspond to two independent distributions.<br>
747 : !> \param[in] lower : The input scalar of the same type and kind as `X`, representing the lower bound of the Uniform distribution.<br>
748 : !> (**optional**, default = `0`. If present, then `upper` must also be present.)
749 : !> \param[in] upper : The input scalar of the same type and kind as `X`, representing the upper bound of the Uniform distribution.<br>
750 : !> (**optional**, default = `1`. If present, then `lower` must also be present.)
751 : !>
752 : !> \interface{setUnifCDF}
753 : !> \code{.F90}
754 : !>
755 : !> use pm_distUnif, only: setUnifCDF
756 : !>
757 : !> call setUnifCDF(cdf, X)
758 : !> call setUnifCDF(cdf, X, lower, upper)
759 : !>
760 : !> \endcode
761 : !>
762 : !> \warnpure
763 : !>
764 : !> \elemental
765 : !>
766 : !> \see
767 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
768 : !>
769 : !> \example{setUnifCDF}
770 : !> \include{lineno} example/pm_distUnif/setUnifCDF/main.F90
771 : !> \compilef{setUnifCDF}
772 : !> \output{setUnifCDF}
773 : !> \include{lineno} example/pm_distUnif/setUnifCDF/main.out.F90
774 : !> \postproc{setUnifCDF}
775 : !> \include{lineno} example/pm_distUnif/setUnifCDF/main.py
776 : !> \vis{setUnifCDF}
777 : !> \image html pm_distUnif/setUnifCDF/setUnifCDF.IK.png width=700
778 : !> \image html pm_distUnif/setUnifCDF/setUnifCDF.RK.png width=700
779 : !> \image html pm_distUnif/setUnifCDF/setUnifCDF.CK.png width=700
780 : !>
781 : !> \test
782 : !> [test_pm_distUnif](@ref test_pm_distUnif)
783 : !>
784 : !> \todo
785 : !> \plow This generic interface can be extended to input arguments with ranks higher than `1`.
786 : !>
787 : !> \todo
788 : !> \pmed This generic interface can be extended to input string arguments to make it compatible with [setUnifRand](@ref pm_distUnif::setUnifRand).
789 : !>
790 : !> \finmain{setUnifCDF}
791 : !>
792 : !> \author
793 : !> \AmirShahmoradi, Oct 16, 2009, 11:14 AM, Michigan
794 :
795 : ! default range.
796 :
797 : interface setUnifCDF
798 :
799 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
800 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
801 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
802 :
803 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
804 :
805 : #if RK5_ENABLED && IK5_ENABLED
806 : PURE module subroutine setUnifCDF_DD_D0_RK5_IK5(cdf, x)
807 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
808 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK5_IK5
809 : #endif
810 : use pm_kind, only: IKC => IK5, RKC => RK5
811 : real(RKC) , intent(out) :: cdf
812 : integer(IKC), intent(in) :: x
813 : end subroutine
814 : #endif
815 :
816 : #if RK4_ENABLED && IK5_ENABLED
817 : PURE module subroutine setUnifCDF_DD_D0_RK4_IK5(cdf, x)
818 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
819 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK4_IK5
820 : #endif
821 : use pm_kind, only: IKC => IK5, RKC => RK4
822 : real(RKC) , intent(out) :: cdf
823 : integer(IKC), intent(in) :: x
824 : end subroutine
825 : #endif
826 :
827 : #if RK3_ENABLED && IK5_ENABLED
828 : PURE module subroutine setUnifCDF_DD_D0_RK3_IK5(cdf, x)
829 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
830 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK3_IK5
831 : #endif
832 : use pm_kind, only: IKC => IK5, RKC => RK3
833 : real(RKC) , intent(out) :: cdf
834 : integer(IKC), intent(in) :: x
835 : end subroutine
836 : #endif
837 :
838 : #if RK2_ENABLED && IK5_ENABLED
839 : PURE module subroutine setUnifCDF_DD_D0_RK2_IK5(cdf, x)
840 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
841 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK2_IK5
842 : #endif
843 : use pm_kind, only: IKC => IK5, RKC => RK2
844 : real(RKC) , intent(out) :: cdf
845 : integer(IKC), intent(in) :: x
846 : end subroutine
847 : #endif
848 :
849 : #if RK1_ENABLED && IK5_ENABLED
850 : PURE module subroutine setUnifCDF_DD_D0_RK1_IK5(cdf, x)
851 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
852 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK1_IK5
853 : #endif
854 : use pm_kind, only: IKC => IK5, RKC => RK1
855 : real(RKC) , intent(out) :: cdf
856 : integer(IKC), intent(in) :: x
857 : end subroutine
858 : #endif
859 :
860 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
861 :
862 : #if RK5_ENABLED && IK4_ENABLED
863 : PURE module subroutine setUnifCDF_DD_D0_RK5_IK4(cdf, x)
864 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
865 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK5_IK4
866 : #endif
867 : use pm_kind, only: IKC => IK4, RKC => RK5
868 : real(RKC) , intent(out) :: cdf
869 : integer(IKC), intent(in) :: x
870 : end subroutine
871 : #endif
872 :
873 : #if RK4_ENABLED && IK4_ENABLED
874 : PURE module subroutine setUnifCDF_DD_D0_RK4_IK4(cdf, x)
875 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
876 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK4_IK4
877 : #endif
878 : use pm_kind, only: IKC => IK4, RKC => RK4
879 : real(RKC) , intent(out) :: cdf
880 : integer(IKC), intent(in) :: x
881 : end subroutine
882 : #endif
883 :
884 : #if RK3_ENABLED && IK4_ENABLED
885 : PURE module subroutine setUnifCDF_DD_D0_RK3_IK4(cdf, x)
886 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
887 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK3_IK4
888 : #endif
889 : use pm_kind, only: IKC => IK4, RKC => RK3
890 : real(RKC) , intent(out) :: cdf
891 : integer(IKC), intent(in) :: x
892 : end subroutine
893 : #endif
894 :
895 : #if RK2_ENABLED && IK4_ENABLED
896 : PURE module subroutine setUnifCDF_DD_D0_RK2_IK4(cdf, x)
897 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
898 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK2_IK4
899 : #endif
900 : use pm_kind, only: IKC => IK4, RKC => RK2
901 : real(RKC) , intent(out) :: cdf
902 : integer(IKC), intent(in) :: x
903 : end subroutine
904 : #endif
905 :
906 : #if RK1_ENABLED && IK4_ENABLED
907 : PURE module subroutine setUnifCDF_DD_D0_RK1_IK4(cdf, x)
908 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
909 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK1_IK4
910 : #endif
911 : use pm_kind, only: IKC => IK4, RKC => RK1
912 : real(RKC) , intent(out) :: cdf
913 : integer(IKC), intent(in) :: x
914 : end subroutine
915 : #endif
916 :
917 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
918 :
919 : #if RK5_ENABLED && IK3_ENABLED
920 : PURE module subroutine setUnifCDF_DD_D0_RK5_IK3(cdf, x)
921 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
922 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK5_IK3
923 : #endif
924 : use pm_kind, only: IKC => IK3, RKC => RK5
925 : real(RKC) , intent(out) :: cdf
926 : integer(IKC), intent(in) :: x
927 : end subroutine
928 : #endif
929 :
930 : #if RK4_ENABLED && IK3_ENABLED
931 : PURE module subroutine setUnifCDF_DD_D0_RK4_IK3(cdf, x)
932 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
933 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK4_IK3
934 : #endif
935 : use pm_kind, only: IKC => IK3, RKC => RK4
936 : real(RKC) , intent(out) :: cdf
937 : integer(IKC), intent(in) :: x
938 : end subroutine
939 : #endif
940 :
941 : #if RK3_ENABLED && IK3_ENABLED
942 : PURE module subroutine setUnifCDF_DD_D0_RK3_IK3(cdf, x)
943 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
944 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK3_IK3
945 : #endif
946 : use pm_kind, only: IKC => IK3, RKC => RK3
947 : real(RKC) , intent(out) :: cdf
948 : integer(IKC), intent(in) :: x
949 : end subroutine
950 : #endif
951 :
952 : #if RK2_ENABLED && IK3_ENABLED
953 : PURE module subroutine setUnifCDF_DD_D0_RK2_IK3(cdf, x)
954 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
955 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK2_IK3
956 : #endif
957 : use pm_kind, only: IKC => IK3, RKC => RK2
958 : real(RKC) , intent(out) :: cdf
959 : integer(IKC), intent(in) :: x
960 : end subroutine
961 : #endif
962 :
963 : #if RK1_ENABLED && IK3_ENABLED
964 : PURE module subroutine setUnifCDF_DD_D0_RK1_IK3(cdf, x)
965 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
966 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK1_IK3
967 : #endif
968 : use pm_kind, only: IKC => IK3, RKC => RK1
969 : real(RKC) , intent(out) :: cdf
970 : integer(IKC), intent(in) :: x
971 : end subroutine
972 : #endif
973 :
974 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
975 :
976 : #if RK5_ENABLED && IK2_ENABLED
977 : PURE module subroutine setUnifCDF_DD_D0_RK5_IK2(cdf, x)
978 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
979 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK5_IK2
980 : #endif
981 : use pm_kind, only: IKC => IK2, RKC => RK5
982 : real(RKC) , intent(out) :: cdf
983 : integer(IKC), intent(in) :: x
984 : end subroutine
985 : #endif
986 :
987 : #if RK4_ENABLED && IK2_ENABLED
988 : PURE module subroutine setUnifCDF_DD_D0_RK4_IK2(cdf, x)
989 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
990 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK4_IK2
991 : #endif
992 : use pm_kind, only: IKC => IK2, RKC => RK4
993 : real(RKC) , intent(out) :: cdf
994 : integer(IKC), intent(in) :: x
995 : end subroutine
996 : #endif
997 :
998 : #if RK3_ENABLED && IK2_ENABLED
999 : PURE module subroutine setUnifCDF_DD_D0_RK3_IK2(cdf, x)
1000 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1001 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK3_IK2
1002 : #endif
1003 : use pm_kind, only: IKC => IK2, RKC => RK3
1004 : real(RKC) , intent(out) :: cdf
1005 : integer(IKC), intent(in) :: x
1006 : end subroutine
1007 : #endif
1008 :
1009 : #if RK2_ENABLED && IK2_ENABLED
1010 : PURE module subroutine setUnifCDF_DD_D0_RK2_IK2(cdf, x)
1011 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1012 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK2_IK2
1013 : #endif
1014 : use pm_kind, only: IKC => IK2, RKC => RK2
1015 : real(RKC) , intent(out) :: cdf
1016 : integer(IKC), intent(in) :: x
1017 : end subroutine
1018 : #endif
1019 :
1020 : #if RK1_ENABLED && IK2_ENABLED
1021 : PURE module subroutine setUnifCDF_DD_D0_RK1_IK2(cdf, x)
1022 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1023 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK1_IK2
1024 : #endif
1025 : use pm_kind, only: IKC => IK2, RKC => RK1
1026 : real(RKC) , intent(out) :: cdf
1027 : integer(IKC), intent(in) :: x
1028 : end subroutine
1029 : #endif
1030 :
1031 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1032 :
1033 : #if RK5_ENABLED && IK1_ENABLED
1034 : PURE module subroutine setUnifCDF_DD_D0_RK5_IK1(cdf, x)
1035 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1036 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK5_IK1
1037 : #endif
1038 : use pm_kind, only: IKC => IK1, RKC => RK5
1039 : real(RKC) , intent(out) :: cdf
1040 : integer(IKC), intent(in) :: x
1041 : end subroutine
1042 : #endif
1043 :
1044 : #if RK4_ENABLED && IK1_ENABLED
1045 : PURE module subroutine setUnifCDF_DD_D0_RK4_IK1(cdf, x)
1046 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1047 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK4_IK1
1048 : #endif
1049 : use pm_kind, only: IKC => IK1, RKC => RK4
1050 : real(RKC) , intent(out) :: cdf
1051 : integer(IKC), intent(in) :: x
1052 : end subroutine
1053 : #endif
1054 :
1055 : #if RK3_ENABLED && IK1_ENABLED
1056 : PURE module subroutine setUnifCDF_DD_D0_RK3_IK1(cdf, x)
1057 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1058 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK3_IK1
1059 : #endif
1060 : use pm_kind, only: IKC => IK1, RKC => RK3
1061 : real(RKC) , intent(out) :: cdf
1062 : integer(IKC), intent(in) :: x
1063 : end subroutine
1064 : #endif
1065 :
1066 : #if RK2_ENABLED && IK1_ENABLED
1067 : PURE module subroutine setUnifCDF_DD_D0_RK2_IK1(cdf, x)
1068 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1069 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK2_IK1
1070 : #endif
1071 : use pm_kind, only: IKC => IK1, RKC => RK2
1072 : real(RKC) , intent(out) :: cdf
1073 : integer(IKC), intent(in) :: x
1074 : end subroutine
1075 : #endif
1076 :
1077 : #if RK1_ENABLED && IK1_ENABLED
1078 : PURE module subroutine setUnifCDF_DD_D0_RK1_IK1(cdf, x)
1079 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1080 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK1_IK1
1081 : #endif
1082 : use pm_kind, only: IKC => IK1, RKC => RK1
1083 : real(RKC) , intent(out) :: cdf
1084 : integer(IKC), intent(in) :: x
1085 : end subroutine
1086 : #endif
1087 :
1088 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1089 :
1090 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1091 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1092 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1093 :
1094 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1095 :
1096 : #if CK5_ENABLED
1097 : PURE module subroutine setUnifCDF_DD_D0_CK5(cdf, x)
1098 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1099 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_CK5
1100 : #endif
1101 : use pm_kind, only: CKC => CK5
1102 : complex(CKC), intent(out) :: cdf
1103 : complex(CKC), intent(in) :: x
1104 : end subroutine
1105 : #endif
1106 :
1107 : #if CK4_ENABLED
1108 : PURE module subroutine setUnifCDF_DD_D0_CK4(cdf, x)
1109 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1110 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_CK4
1111 : #endif
1112 : use pm_kind, only: CKC => CK4
1113 : complex(CKC), intent(out) :: cdf
1114 : complex(CKC), intent(in) :: x
1115 : end subroutine
1116 : #endif
1117 :
1118 : #if CK3_ENABLED
1119 : PURE module subroutine setUnifCDF_DD_D0_CK3(cdf, x)
1120 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1121 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_CK3
1122 : #endif
1123 : use pm_kind, only: CKC => CK3
1124 : complex(CKC), intent(out) :: cdf
1125 : complex(CKC), intent(in) :: x
1126 : end subroutine
1127 : #endif
1128 :
1129 : #if CK2_ENABLED
1130 : PURE module subroutine setUnifCDF_DD_D0_CK2(cdf, x)
1131 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1132 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_CK2
1133 : #endif
1134 : use pm_kind, only: CKC => CK2
1135 : complex(CKC), intent(out) :: cdf
1136 : complex(CKC), intent(in) :: x
1137 : end subroutine
1138 : #endif
1139 :
1140 : #if CK1_ENABLED
1141 : PURE module subroutine setUnifCDF_DD_D0_CK1(cdf, x)
1142 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1143 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_CK1
1144 : #endif
1145 : use pm_kind, only: CKC => CK1
1146 : complex(CKC), intent(out) :: cdf
1147 : complex(CKC), intent(in) :: x
1148 : end subroutine
1149 : #endif
1150 :
1151 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1152 :
1153 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1154 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1155 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1156 :
1157 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1158 :
1159 : #if RK5_ENABLED
1160 : PURE module subroutine setUnifCDF_DD_D0_RK5(cdf, x)
1161 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1162 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK5
1163 : #endif
1164 : use pm_kind, only: RKC => RK5
1165 : real(RKC) , intent(out) :: cdf
1166 : real(RKC) , intent(in) :: x
1167 : end subroutine
1168 : #endif
1169 :
1170 : #if RK4_ENABLED
1171 : PURE module subroutine setUnifCDF_DD_D0_RK4(cdf, x)
1172 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1173 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK4
1174 : #endif
1175 : use pm_kind, only: RKC => RK4
1176 : real(RKC) , intent(out) :: cdf
1177 : real(RKC) , intent(in) :: x
1178 : end subroutine
1179 : #endif
1180 :
1181 : #if RK3_ENABLED
1182 : PURE module subroutine setUnifCDF_DD_D0_RK3(cdf, x)
1183 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1184 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK3
1185 : #endif
1186 : use pm_kind, only: RKC => RK3
1187 : real(RKC) , intent(out) :: cdf
1188 : real(RKC) , intent(in) :: x
1189 : end subroutine
1190 : #endif
1191 :
1192 : #if RK2_ENABLED
1193 : PURE module subroutine setUnifCDF_DD_D0_RK2(cdf, x)
1194 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1195 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK2
1196 : #endif
1197 : use pm_kind, only: RKC => RK2
1198 : real(RKC) , intent(out) :: cdf
1199 : real(RKC) , intent(in) :: x
1200 : end subroutine
1201 : #endif
1202 :
1203 : #if RK1_ENABLED
1204 : PURE module subroutine setUnifCDF_DD_D0_RK1(cdf, x)
1205 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1206 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D0_RK1
1207 : #endif
1208 : use pm_kind, only: RKC => RK1
1209 : real(RKC) , intent(out) :: cdf
1210 : real(RKC) , intent(in) :: x
1211 : end subroutine
1212 : #endif
1213 :
1214 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1215 :
1216 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1217 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1218 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1219 :
1220 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1221 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1222 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1223 :
1224 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1225 :
1226 : #if RK5_ENABLED && IK5_ENABLED
1227 : PURE module subroutine setUnifCDF_DD_D1_RK5_IK5(cdf, X)
1228 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1229 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK5_IK5
1230 : #endif
1231 : use pm_kind, only: IKC => IK5, RKC => RK5
1232 : real(RKC) , intent(out) , contiguous :: cdf(:)
1233 : integer(IKC), intent(in) , contiguous :: X(:)
1234 : end subroutine
1235 : #endif
1236 :
1237 : #if RK4_ENABLED && IK5_ENABLED
1238 : PURE module subroutine setUnifCDF_DD_D1_RK4_IK5(cdf, X)
1239 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1240 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK4_IK5
1241 : #endif
1242 : use pm_kind, only: IKC => IK5, RKC => RK4
1243 : real(RKC) , intent(out) , contiguous :: cdf(:)
1244 : integer(IKC), intent(in) , contiguous :: X(:)
1245 : end subroutine
1246 : #endif
1247 :
1248 : #if RK3_ENABLED && IK5_ENABLED
1249 : PURE module subroutine setUnifCDF_DD_D1_RK3_IK5(cdf, X)
1250 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1251 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK3_IK5
1252 : #endif
1253 : use pm_kind, only: IKC => IK5, RKC => RK3
1254 : real(RKC) , intent(out) , contiguous :: cdf(:)
1255 : integer(IKC), intent(in) , contiguous :: X(:)
1256 : end subroutine
1257 : #endif
1258 :
1259 : #if RK2_ENABLED && IK5_ENABLED
1260 : PURE module subroutine setUnifCDF_DD_D1_RK2_IK5(cdf, X)
1261 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1262 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK2_IK5
1263 : #endif
1264 : use pm_kind, only: IKC => IK5, RKC => RK2
1265 : real(RKC) , intent(out) , contiguous :: cdf(:)
1266 : integer(IKC), intent(in) , contiguous :: X(:)
1267 : end subroutine
1268 : #endif
1269 :
1270 : #if RK1_ENABLED && IK5_ENABLED
1271 : PURE module subroutine setUnifCDF_DD_D1_RK1_IK5(cdf, X)
1272 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1273 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK1_IK5
1274 : #endif
1275 : use pm_kind, only: IKC => IK5, RKC => RK1
1276 : real(RKC) , intent(out) , contiguous :: cdf(:)
1277 : integer(IKC), intent(in) , contiguous :: X(:)
1278 : end subroutine
1279 : #endif
1280 :
1281 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1282 :
1283 : #if RK5_ENABLED && IK4_ENABLED
1284 : PURE module subroutine setUnifCDF_DD_D1_RK5_IK4(cdf, X)
1285 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1286 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK5_IK4
1287 : #endif
1288 : use pm_kind, only: IKC => IK4, RKC => RK5
1289 : real(RKC) , intent(out) , contiguous :: cdf(:)
1290 : integer(IKC), intent(in) , contiguous :: X(:)
1291 : end subroutine
1292 : #endif
1293 :
1294 : #if RK4_ENABLED && IK4_ENABLED
1295 : PURE module subroutine setUnifCDF_DD_D1_RK4_IK4(cdf, X)
1296 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1297 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK4_IK4
1298 : #endif
1299 : use pm_kind, only: IKC => IK4, RKC => RK4
1300 : real(RKC) , intent(out) , contiguous :: cdf(:)
1301 : integer(IKC), intent(in) , contiguous :: X(:)
1302 : end subroutine
1303 : #endif
1304 :
1305 : #if RK3_ENABLED && IK4_ENABLED
1306 : PURE module subroutine setUnifCDF_DD_D1_RK3_IK4(cdf, X)
1307 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1308 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK3_IK4
1309 : #endif
1310 : use pm_kind, only: IKC => IK4, RKC => RK3
1311 : real(RKC) , intent(out) , contiguous :: cdf(:)
1312 : integer(IKC), intent(in) , contiguous :: X(:)
1313 : end subroutine
1314 : #endif
1315 :
1316 : #if RK2_ENABLED && IK4_ENABLED
1317 : PURE module subroutine setUnifCDF_DD_D1_RK2_IK4(cdf, X)
1318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1319 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK2_IK4
1320 : #endif
1321 : use pm_kind, only: IKC => IK4, RKC => RK2
1322 : real(RKC) , intent(out) , contiguous :: cdf(:)
1323 : integer(IKC), intent(in) , contiguous :: X(:)
1324 : end subroutine
1325 : #endif
1326 :
1327 : #if RK1_ENABLED && IK4_ENABLED
1328 : PURE module subroutine setUnifCDF_DD_D1_RK1_IK4(cdf, X)
1329 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1330 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK1_IK4
1331 : #endif
1332 : use pm_kind, only: IKC => IK4, RKC => RK1
1333 : real(RKC) , intent(out) , contiguous :: cdf(:)
1334 : integer(IKC), intent(in) , contiguous :: X(:)
1335 : end subroutine
1336 : #endif
1337 :
1338 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1339 :
1340 : #if RK5_ENABLED && IK3_ENABLED
1341 : PURE module subroutine setUnifCDF_DD_D1_RK5_IK3(cdf, X)
1342 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1343 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK5_IK3
1344 : #endif
1345 : use pm_kind, only: IKC => IK3, RKC => RK5
1346 : real(RKC) , intent(out) , contiguous :: cdf(:)
1347 : integer(IKC), intent(in) , contiguous :: X(:)
1348 : end subroutine
1349 : #endif
1350 :
1351 : #if RK4_ENABLED && IK3_ENABLED
1352 : PURE module subroutine setUnifCDF_DD_D1_RK4_IK3(cdf, X)
1353 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1354 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK4_IK3
1355 : #endif
1356 : use pm_kind, only: IKC => IK3, RKC => RK4
1357 : real(RKC) , intent(out) , contiguous :: cdf(:)
1358 : integer(IKC), intent(in) , contiguous :: X(:)
1359 : end subroutine
1360 : #endif
1361 :
1362 : #if RK3_ENABLED && IK3_ENABLED
1363 : PURE module subroutine setUnifCDF_DD_D1_RK3_IK3(cdf, X)
1364 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1365 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK3_IK3
1366 : #endif
1367 : use pm_kind, only: IKC => IK3, RKC => RK3
1368 : real(RKC) , intent(out) , contiguous :: cdf(:)
1369 : integer(IKC), intent(in) , contiguous :: X(:)
1370 : end subroutine
1371 : #endif
1372 :
1373 : #if RK2_ENABLED && IK3_ENABLED
1374 : PURE module subroutine setUnifCDF_DD_D1_RK2_IK3(cdf, X)
1375 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1376 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK2_IK3
1377 : #endif
1378 : use pm_kind, only: IKC => IK3, RKC => RK2
1379 : real(RKC) , intent(out) , contiguous :: cdf(:)
1380 : integer(IKC), intent(in) , contiguous :: X(:)
1381 : end subroutine
1382 : #endif
1383 :
1384 : #if RK1_ENABLED && IK3_ENABLED
1385 : PURE module subroutine setUnifCDF_DD_D1_RK1_IK3(cdf, X)
1386 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1387 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK1_IK3
1388 : #endif
1389 : use pm_kind, only: IKC => IK3, RKC => RK1
1390 : real(RKC) , intent(out) , contiguous :: cdf(:)
1391 : integer(IKC), intent(in) , contiguous :: X(:)
1392 : end subroutine
1393 : #endif
1394 :
1395 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1396 :
1397 : #if RK5_ENABLED && IK2_ENABLED
1398 : PURE module subroutine setUnifCDF_DD_D1_RK5_IK2(cdf, X)
1399 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1400 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK5_IK2
1401 : #endif
1402 : use pm_kind, only: IKC => IK2, RKC => RK5
1403 : real(RKC) , intent(out) , contiguous :: cdf(:)
1404 : integer(IKC), intent(in) , contiguous :: X(:)
1405 : end subroutine
1406 : #endif
1407 :
1408 : #if RK4_ENABLED && IK2_ENABLED
1409 : PURE module subroutine setUnifCDF_DD_D1_RK4_IK2(cdf, X)
1410 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1411 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK4_IK2
1412 : #endif
1413 : use pm_kind, only: IKC => IK2, RKC => RK4
1414 : real(RKC) , intent(out) , contiguous :: cdf(:)
1415 : integer(IKC), intent(in) , contiguous :: X(:)
1416 : end subroutine
1417 : #endif
1418 :
1419 : #if RK3_ENABLED && IK2_ENABLED
1420 : PURE module subroutine setUnifCDF_DD_D1_RK3_IK2(cdf, X)
1421 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1422 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK3_IK2
1423 : #endif
1424 : use pm_kind, only: IKC => IK2, RKC => RK3
1425 : real(RKC) , intent(out) , contiguous :: cdf(:)
1426 : integer(IKC), intent(in) , contiguous :: X(:)
1427 : end subroutine
1428 : #endif
1429 :
1430 : #if RK2_ENABLED && IK2_ENABLED
1431 : PURE module subroutine setUnifCDF_DD_D1_RK2_IK2(cdf, X)
1432 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1433 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK2_IK2
1434 : #endif
1435 : use pm_kind, only: IKC => IK2, RKC => RK2
1436 : real(RKC) , intent(out) , contiguous :: cdf(:)
1437 : integer(IKC), intent(in) , contiguous :: X(:)
1438 : end subroutine
1439 : #endif
1440 :
1441 : #if RK1_ENABLED && IK2_ENABLED
1442 : PURE module subroutine setUnifCDF_DD_D1_RK1_IK2(cdf, X)
1443 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1444 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK1_IK2
1445 : #endif
1446 : use pm_kind, only: IKC => IK2, RKC => RK1
1447 : real(RKC) , intent(out) , contiguous :: cdf(:)
1448 : integer(IKC), intent(in) , contiguous :: X(:)
1449 : end subroutine
1450 : #endif
1451 :
1452 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1453 :
1454 : #if RK5_ENABLED && IK1_ENABLED
1455 : PURE module subroutine setUnifCDF_DD_D1_RK5_IK1(cdf, X)
1456 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1457 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK5_IK1
1458 : #endif
1459 : use pm_kind, only: IKC => IK1, RKC => RK5
1460 : real(RKC) , intent(out) , contiguous :: cdf(:)
1461 : integer(IKC), intent(in) , contiguous :: X(:)
1462 : end subroutine
1463 : #endif
1464 :
1465 : #if RK4_ENABLED && IK1_ENABLED
1466 : PURE module subroutine setUnifCDF_DD_D1_RK4_IK1(cdf, X)
1467 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1468 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK4_IK1
1469 : #endif
1470 : use pm_kind, only: IKC => IK1, RKC => RK4
1471 : real(RKC) , intent(out) , contiguous :: cdf(:)
1472 : integer(IKC), intent(in) , contiguous :: X(:)
1473 : end subroutine
1474 : #endif
1475 :
1476 : #if RK3_ENABLED && IK1_ENABLED
1477 : PURE module subroutine setUnifCDF_DD_D1_RK3_IK1(cdf, X)
1478 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1479 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK3_IK1
1480 : #endif
1481 : use pm_kind, only: IKC => IK1, RKC => RK3
1482 : real(RKC) , intent(out) , contiguous :: cdf(:)
1483 : integer(IKC), intent(in) , contiguous :: X(:)
1484 : end subroutine
1485 : #endif
1486 :
1487 : #if RK2_ENABLED && IK1_ENABLED
1488 : PURE module subroutine setUnifCDF_DD_D1_RK2_IK1(cdf, X)
1489 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1490 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK2_IK1
1491 : #endif
1492 : use pm_kind, only: IKC => IK1, RKC => RK2
1493 : real(RKC) , intent(out) , contiguous :: cdf(:)
1494 : integer(IKC), intent(in) , contiguous :: X(:)
1495 : end subroutine
1496 : #endif
1497 :
1498 : #if RK1_ENABLED && IK1_ENABLED
1499 : PURE module subroutine setUnifCDF_DD_D1_RK1_IK1(cdf, X)
1500 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1501 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK1_IK1
1502 : #endif
1503 : use pm_kind, only: IKC => IK1, RKC => RK1
1504 : real(RKC) , intent(out) , contiguous :: cdf(:)
1505 : integer(IKC), intent(in) , contiguous :: X(:)
1506 : end subroutine
1507 : #endif
1508 :
1509 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1510 :
1511 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1512 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1513 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1514 :
1515 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1516 :
1517 : #if CK5_ENABLED
1518 : PURE module subroutine setUnifCDF_DD_D1_CK5(cdf, X)
1519 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1520 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_CK5
1521 : #endif
1522 : use pm_kind, only: CKC => CK5
1523 : complex(CKC), intent(out) , contiguous :: cdf(:)
1524 : complex(CKC), intent(in) , contiguous :: X(:)
1525 : end subroutine
1526 : #endif
1527 :
1528 : #if CK4_ENABLED
1529 : PURE module subroutine setUnifCDF_DD_D1_CK4(cdf, X)
1530 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1531 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_CK4
1532 : #endif
1533 : use pm_kind, only: CKC => CK4
1534 : complex(CKC), intent(out) , contiguous :: cdf(:)
1535 : complex(CKC), intent(in) , contiguous :: X(:)
1536 : end subroutine
1537 : #endif
1538 :
1539 : #if CK3_ENABLED
1540 : PURE module subroutine setUnifCDF_DD_D1_CK3(cdf, X)
1541 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1542 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_CK3
1543 : #endif
1544 : use pm_kind, only: CKC => CK3
1545 : complex(CKC), intent(out) , contiguous :: cdf(:)
1546 : complex(CKC), intent(in) , contiguous :: X(:)
1547 : end subroutine
1548 : #endif
1549 :
1550 : #if CK2_ENABLED
1551 : PURE module subroutine setUnifCDF_DD_D1_CK2(cdf, X)
1552 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1553 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_CK2
1554 : #endif
1555 : use pm_kind, only: CKC => CK2
1556 : complex(CKC), intent(out) , contiguous :: cdf(:)
1557 : complex(CKC), intent(in) , contiguous :: X(:)
1558 : end subroutine
1559 : #endif
1560 :
1561 : #if CK1_ENABLED
1562 : PURE module subroutine setUnifCDF_DD_D1_CK1(cdf, X)
1563 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1564 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_CK1
1565 : #endif
1566 : use pm_kind, only: CKC => CK1
1567 : complex(CKC), intent(out) , contiguous :: cdf(:)
1568 : complex(CKC), intent(in) , contiguous :: X(:)
1569 : end subroutine
1570 : #endif
1571 :
1572 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1573 :
1574 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1575 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1576 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1577 :
1578 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1579 :
1580 : #if RK5_ENABLED
1581 : PURE module subroutine setUnifCDF_DD_D1_RK5(cdf, X)
1582 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1583 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK5
1584 : #endif
1585 : use pm_kind, only: RKC => RK5
1586 : real(RKC) , intent(out) , contiguous :: cdf(:)
1587 : real(RKC) , intent(in) , contiguous :: X(:)
1588 : end subroutine
1589 : #endif
1590 :
1591 : #if RK4_ENABLED
1592 : PURE module subroutine setUnifCDF_DD_D1_RK4(cdf, X)
1593 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1594 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK4
1595 : #endif
1596 : use pm_kind, only: RKC => RK4
1597 : real(RKC) , intent(out) , contiguous :: cdf(:)
1598 : real(RKC) , intent(in) , contiguous :: X(:)
1599 : end subroutine
1600 : #endif
1601 :
1602 : #if RK3_ENABLED
1603 : PURE module subroutine setUnifCDF_DD_D1_RK3(cdf, X)
1604 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1605 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK3
1606 : #endif
1607 : use pm_kind, only: RKC => RK3
1608 : real(RKC) , intent(out) , contiguous :: cdf(:)
1609 : real(RKC) , intent(in) , contiguous :: X(:)
1610 : end subroutine
1611 : #endif
1612 :
1613 : #if RK2_ENABLED
1614 : PURE module subroutine setUnifCDF_DD_D1_RK2(cdf, X)
1615 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1616 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK2
1617 : #endif
1618 : use pm_kind, only: RKC => RK2
1619 : real(RKC) , intent(out) , contiguous :: cdf(:)
1620 : real(RKC) , intent(in) , contiguous :: X(:)
1621 : end subroutine
1622 : #endif
1623 :
1624 : #if RK1_ENABLED
1625 : PURE module subroutine setUnifCDF_DD_D1_RK1(cdf, X)
1626 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1627 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_DD_D1_RK1
1628 : #endif
1629 : use pm_kind, only: RKC => RK1
1630 : real(RKC) , intent(out) , contiguous :: cdf(:)
1631 : real(RKC) , intent(in) , contiguous :: X(:)
1632 : end subroutine
1633 : #endif
1634 :
1635 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1636 :
1637 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1638 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1639 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1640 :
1641 : end interface
1642 :
1643 : ! custom range.
1644 :
1645 : interface setUnifCDF
1646 :
1647 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1648 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1649 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1650 :
1651 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1652 :
1653 : #if RK5_ENABLED && IK5_ENABLED
1654 : PURE module subroutine setUnifCDF_LU_D0_RK5_IK5(cdf, x, lower, upper)
1655 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1656 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK5_IK5
1657 : #endif
1658 : use pm_kind, only: IKC => IK5, RKC => RK5
1659 : real(RKC) , intent(out) :: cdf
1660 : integer(IKC), intent(in) :: x
1661 : integer(IKC), intent(in) :: lower, upper
1662 : end subroutine
1663 : #endif
1664 :
1665 : #if RK4_ENABLED && IK5_ENABLED
1666 : PURE module subroutine setUnifCDF_LU_D0_RK4_IK5(cdf, x, lower, upper)
1667 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1668 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK4_IK5
1669 : #endif
1670 : use pm_kind, only: IKC => IK5, RKC => RK4
1671 : real(RKC) , intent(out) :: cdf
1672 : integer(IKC), intent(in) :: x
1673 : integer(IKC), intent(in) :: lower, upper
1674 : end subroutine
1675 : #endif
1676 :
1677 : #if RK3_ENABLED && IK5_ENABLED
1678 : PURE module subroutine setUnifCDF_LU_D0_RK3_IK5(cdf, x, lower, upper)
1679 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1680 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK3_IK5
1681 : #endif
1682 : use pm_kind, only: IKC => IK5, RKC => RK3
1683 : real(RKC) , intent(out) :: cdf
1684 : integer(IKC), intent(in) :: x
1685 : integer(IKC), intent(in) :: lower, upper
1686 : end subroutine
1687 : #endif
1688 :
1689 : #if RK2_ENABLED && IK5_ENABLED
1690 : PURE module subroutine setUnifCDF_LU_D0_RK2_IK5(cdf, x, lower, upper)
1691 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1692 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK2_IK5
1693 : #endif
1694 : use pm_kind, only: IKC => IK5, RKC => RK2
1695 : real(RKC) , intent(out) :: cdf
1696 : integer(IKC), intent(in) :: x
1697 : integer(IKC), intent(in) :: lower, upper
1698 : end subroutine
1699 : #endif
1700 :
1701 : #if RK1_ENABLED && IK5_ENABLED
1702 : PURE module subroutine setUnifCDF_LU_D0_RK1_IK5(cdf, x, lower, upper)
1703 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1704 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK1_IK5
1705 : #endif
1706 : use pm_kind, only: IKC => IK5, RKC => RK1
1707 : real(RKC) , intent(out) :: cdf
1708 : integer(IKC), intent(in) :: x
1709 : integer(IKC), intent(in) :: lower, upper
1710 : end subroutine
1711 : #endif
1712 :
1713 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1714 :
1715 : #if RK5_ENABLED && IK4_ENABLED
1716 : PURE module subroutine setUnifCDF_LU_D0_RK5_IK4(cdf, x, lower, upper)
1717 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1718 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK5_IK4
1719 : #endif
1720 : use pm_kind, only: IKC => IK4, RKC => RK5
1721 : real(RKC) , intent(out) :: cdf
1722 : integer(IKC), intent(in) :: x
1723 : integer(IKC), intent(in) :: lower, upper
1724 : end subroutine
1725 : #endif
1726 :
1727 : #if RK4_ENABLED && IK4_ENABLED
1728 : PURE module subroutine setUnifCDF_LU_D0_RK4_IK4(cdf, x, lower, upper)
1729 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1730 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK4_IK4
1731 : #endif
1732 : use pm_kind, only: IKC => IK4, RKC => RK4
1733 : real(RKC) , intent(out) :: cdf
1734 : integer(IKC), intent(in) :: x
1735 : integer(IKC), intent(in) :: lower, upper
1736 : end subroutine
1737 : #endif
1738 :
1739 : #if RK3_ENABLED && IK4_ENABLED
1740 : PURE module subroutine setUnifCDF_LU_D0_RK3_IK4(cdf, x, lower, upper)
1741 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1742 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK3_IK4
1743 : #endif
1744 : use pm_kind, only: IKC => IK4, RKC => RK3
1745 : real(RKC) , intent(out) :: cdf
1746 : integer(IKC), intent(in) :: x
1747 : integer(IKC), intent(in) :: lower, upper
1748 : end subroutine
1749 : #endif
1750 :
1751 : #if RK2_ENABLED && IK4_ENABLED
1752 : PURE module subroutine setUnifCDF_LU_D0_RK2_IK4(cdf, x, lower, upper)
1753 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1754 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK2_IK4
1755 : #endif
1756 : use pm_kind, only: IKC => IK4, RKC => RK2
1757 : real(RKC) , intent(out) :: cdf
1758 : integer(IKC), intent(in) :: x
1759 : integer(IKC), intent(in) :: lower, upper
1760 : end subroutine
1761 : #endif
1762 :
1763 : #if RK1_ENABLED && IK4_ENABLED
1764 : PURE module subroutine setUnifCDF_LU_D0_RK1_IK4(cdf, x, lower, upper)
1765 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1766 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK1_IK4
1767 : #endif
1768 : use pm_kind, only: IKC => IK4, RKC => RK1
1769 : real(RKC) , intent(out) :: cdf
1770 : integer(IKC), intent(in) :: x
1771 : integer(IKC), intent(in) :: lower, upper
1772 : end subroutine
1773 : #endif
1774 :
1775 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1776 :
1777 : #if RK5_ENABLED && IK3_ENABLED
1778 : PURE module subroutine setUnifCDF_LU_D0_RK5_IK3(cdf, x, lower, upper)
1779 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1780 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK5_IK3
1781 : #endif
1782 : use pm_kind, only: IKC => IK3, RKC => RK5
1783 : real(RKC) , intent(out) :: cdf
1784 : integer(IKC), intent(in) :: x
1785 : integer(IKC), intent(in) :: lower, upper
1786 : end subroutine
1787 : #endif
1788 :
1789 : #if RK4_ENABLED && IK3_ENABLED
1790 : PURE module subroutine setUnifCDF_LU_D0_RK4_IK3(cdf, x, lower, upper)
1791 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1792 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK4_IK3
1793 : #endif
1794 : use pm_kind, only: IKC => IK3, RKC => RK4
1795 : real(RKC) , intent(out) :: cdf
1796 : integer(IKC), intent(in) :: x
1797 : integer(IKC), intent(in) :: lower, upper
1798 : end subroutine
1799 : #endif
1800 :
1801 : #if RK3_ENABLED && IK3_ENABLED
1802 : PURE module subroutine setUnifCDF_LU_D0_RK3_IK3(cdf, x, lower, upper)
1803 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1804 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK3_IK3
1805 : #endif
1806 : use pm_kind, only: IKC => IK3, RKC => RK3
1807 : real(RKC) , intent(out) :: cdf
1808 : integer(IKC), intent(in) :: x
1809 : integer(IKC), intent(in) :: lower, upper
1810 : end subroutine
1811 : #endif
1812 :
1813 : #if RK2_ENABLED && IK3_ENABLED
1814 : PURE module subroutine setUnifCDF_LU_D0_RK2_IK3(cdf, x, lower, upper)
1815 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1816 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK2_IK3
1817 : #endif
1818 : use pm_kind, only: IKC => IK3, RKC => RK2
1819 : real(RKC) , intent(out) :: cdf
1820 : integer(IKC), intent(in) :: x
1821 : integer(IKC), intent(in) :: lower, upper
1822 : end subroutine
1823 : #endif
1824 :
1825 : #if RK1_ENABLED && IK3_ENABLED
1826 : PURE module subroutine setUnifCDF_LU_D0_RK1_IK3(cdf, x, lower, upper)
1827 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1828 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK1_IK3
1829 : #endif
1830 : use pm_kind, only: IKC => IK3, RKC => RK1
1831 : real(RKC) , intent(out) :: cdf
1832 : integer(IKC), intent(in) :: x
1833 : integer(IKC), intent(in) :: lower, upper
1834 : end subroutine
1835 : #endif
1836 :
1837 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1838 :
1839 : #if RK5_ENABLED && IK2_ENABLED
1840 : PURE module subroutine setUnifCDF_LU_D0_RK5_IK2(cdf, x, lower, upper)
1841 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1842 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK5_IK2
1843 : #endif
1844 : use pm_kind, only: IKC => IK2, RKC => RK5
1845 : real(RKC) , intent(out) :: cdf
1846 : integer(IKC), intent(in) :: x
1847 : integer(IKC), intent(in) :: lower, upper
1848 : end subroutine
1849 : #endif
1850 :
1851 : #if RK4_ENABLED && IK2_ENABLED
1852 : PURE module subroutine setUnifCDF_LU_D0_RK4_IK2(cdf, x, lower, upper)
1853 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1854 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK4_IK2
1855 : #endif
1856 : use pm_kind, only: IKC => IK2, RKC => RK4
1857 : real(RKC) , intent(out) :: cdf
1858 : integer(IKC), intent(in) :: x
1859 : integer(IKC), intent(in) :: lower, upper
1860 : end subroutine
1861 : #endif
1862 :
1863 : #if RK3_ENABLED && IK2_ENABLED
1864 : PURE module subroutine setUnifCDF_LU_D0_RK3_IK2(cdf, x, lower, upper)
1865 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1866 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK3_IK2
1867 : #endif
1868 : use pm_kind, only: IKC => IK2, RKC => RK3
1869 : real(RKC) , intent(out) :: cdf
1870 : integer(IKC), intent(in) :: x
1871 : integer(IKC), intent(in) :: lower, upper
1872 : end subroutine
1873 : #endif
1874 :
1875 : #if RK2_ENABLED && IK2_ENABLED
1876 : PURE module subroutine setUnifCDF_LU_D0_RK2_IK2(cdf, x, lower, upper)
1877 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1878 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK2_IK2
1879 : #endif
1880 : use pm_kind, only: IKC => IK2, RKC => RK2
1881 : real(RKC) , intent(out) :: cdf
1882 : integer(IKC), intent(in) :: x
1883 : integer(IKC), intent(in) :: lower, upper
1884 : end subroutine
1885 : #endif
1886 :
1887 : #if RK1_ENABLED && IK2_ENABLED
1888 : PURE module subroutine setUnifCDF_LU_D0_RK1_IK2(cdf, x, lower, upper)
1889 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1890 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK1_IK2
1891 : #endif
1892 : use pm_kind, only: IKC => IK2, RKC => RK1
1893 : real(RKC) , intent(out) :: cdf
1894 : integer(IKC), intent(in) :: x
1895 : integer(IKC), intent(in) :: lower, upper
1896 : end subroutine
1897 : #endif
1898 :
1899 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1900 :
1901 : #if RK5_ENABLED && IK1_ENABLED
1902 : PURE module subroutine setUnifCDF_LU_D0_RK5_IK1(cdf, x, lower, upper)
1903 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1904 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK5_IK1
1905 : #endif
1906 : use pm_kind, only: IKC => IK1, RKC => RK5
1907 : real(RKC) , intent(out) :: cdf
1908 : integer(IKC), intent(in) :: x
1909 : integer(IKC), intent(in) :: lower, upper
1910 : end subroutine
1911 : #endif
1912 :
1913 : #if RK4_ENABLED && IK1_ENABLED
1914 : PURE module subroutine setUnifCDF_LU_D0_RK4_IK1(cdf, x, lower, upper)
1915 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1916 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK4_IK1
1917 : #endif
1918 : use pm_kind, only: IKC => IK1, RKC => RK4
1919 : real(RKC) , intent(out) :: cdf
1920 : integer(IKC), intent(in) :: x
1921 : integer(IKC), intent(in) :: lower, upper
1922 : end subroutine
1923 : #endif
1924 :
1925 : #if RK3_ENABLED && IK1_ENABLED
1926 : PURE module subroutine setUnifCDF_LU_D0_RK3_IK1(cdf, x, lower, upper)
1927 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1928 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK3_IK1
1929 : #endif
1930 : use pm_kind, only: IKC => IK1, RKC => RK3
1931 : real(RKC) , intent(out) :: cdf
1932 : integer(IKC), intent(in) :: x
1933 : integer(IKC), intent(in) :: lower, upper
1934 : end subroutine
1935 : #endif
1936 :
1937 : #if RK2_ENABLED && IK1_ENABLED
1938 : PURE module subroutine setUnifCDF_LU_D0_RK2_IK1(cdf, x, lower, upper)
1939 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1940 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK2_IK1
1941 : #endif
1942 : use pm_kind, only: IKC => IK1, RKC => RK2
1943 : real(RKC) , intent(out) :: cdf
1944 : integer(IKC), intent(in) :: x
1945 : integer(IKC), intent(in) :: lower, upper
1946 : end subroutine
1947 : #endif
1948 :
1949 : #if RK1_ENABLED && IK1_ENABLED
1950 : PURE module subroutine setUnifCDF_LU_D0_RK1_IK1(cdf, x, lower, upper)
1951 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1952 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK1_IK1
1953 : #endif
1954 : use pm_kind, only: IKC => IK1, RKC => RK1
1955 : real(RKC) , intent(out) :: cdf
1956 : integer(IKC), intent(in) :: x
1957 : integer(IKC), intent(in) :: lower, upper
1958 : end subroutine
1959 : #endif
1960 :
1961 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1962 :
1963 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1964 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1965 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1966 :
1967 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1968 :
1969 : #if CK5_ENABLED
1970 : PURE module subroutine setUnifCDF_LU_D0_CK5(cdf, x, lower, upper)
1971 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1972 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_CK5
1973 : #endif
1974 : use pm_kind, only: CKC => CK5
1975 : complex(CKC), intent(out) :: cdf
1976 : complex(CKC), intent(in) :: x
1977 : complex(CKC), intent(in) :: lower, upper
1978 : end subroutine
1979 : #endif
1980 :
1981 : #if CK4_ENABLED
1982 : PURE module subroutine setUnifCDF_LU_D0_CK4(cdf, x, lower, upper)
1983 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1984 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_CK4
1985 : #endif
1986 : use pm_kind, only: CKC => CK4
1987 : complex(CKC), intent(out) :: cdf
1988 : complex(CKC), intent(in) :: x
1989 : complex(CKC), intent(in) :: lower, upper
1990 : end subroutine
1991 : #endif
1992 :
1993 : #if CK3_ENABLED
1994 : PURE module subroutine setUnifCDF_LU_D0_CK3(cdf, x, lower, upper)
1995 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1996 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_CK3
1997 : #endif
1998 : use pm_kind, only: CKC => CK3
1999 : complex(CKC), intent(out) :: cdf
2000 : complex(CKC), intent(in) :: x
2001 : complex(CKC), intent(in) :: lower, upper
2002 : end subroutine
2003 : #endif
2004 :
2005 : #if CK2_ENABLED
2006 : PURE module subroutine setUnifCDF_LU_D0_CK2(cdf, x, lower, upper)
2007 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2008 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_CK2
2009 : #endif
2010 : use pm_kind, only: CKC => CK2
2011 : complex(CKC), intent(out) :: cdf
2012 : complex(CKC), intent(in) :: x
2013 : complex(CKC), intent(in) :: lower, upper
2014 : end subroutine
2015 : #endif
2016 :
2017 : #if CK1_ENABLED
2018 : PURE module subroutine setUnifCDF_LU_D0_CK1(cdf, x, lower, upper)
2019 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2020 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_CK1
2021 : #endif
2022 : use pm_kind, only: CKC => CK1
2023 : complex(CKC), intent(out) :: cdf
2024 : complex(CKC), intent(in) :: x
2025 : complex(CKC), intent(in) :: lower, upper
2026 : end subroutine
2027 : #endif
2028 :
2029 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2030 :
2031 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2032 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2033 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2034 :
2035 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2036 :
2037 : #if RK5_ENABLED
2038 : PURE module subroutine setUnifCDF_LU_D0_RK5(cdf, x, lower, upper)
2039 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2040 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK5
2041 : #endif
2042 : use pm_kind, only: RKC => RK5
2043 : real(RKC) , intent(out) :: cdf
2044 : real(RKC) , intent(in) :: x
2045 : real(RKC) , intent(in) :: lower, upper
2046 : end subroutine
2047 : #endif
2048 :
2049 : #if RK4_ENABLED
2050 : PURE module subroutine setUnifCDF_LU_D0_RK4(cdf, x, lower, upper)
2051 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2052 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK4
2053 : #endif
2054 : use pm_kind, only: RKC => RK4
2055 : real(RKC) , intent(out) :: cdf
2056 : real(RKC) , intent(in) :: x
2057 : real(RKC) , intent(in) :: lower, upper
2058 : end subroutine
2059 : #endif
2060 :
2061 : #if RK3_ENABLED
2062 : PURE module subroutine setUnifCDF_LU_D0_RK3(cdf, x, lower, upper)
2063 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2064 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK3
2065 : #endif
2066 : use pm_kind, only: RKC => RK3
2067 : real(RKC) , intent(out) :: cdf
2068 : real(RKC) , intent(in) :: x
2069 : real(RKC) , intent(in) :: lower, upper
2070 : end subroutine
2071 : #endif
2072 :
2073 : #if RK2_ENABLED
2074 : PURE module subroutine setUnifCDF_LU_D0_RK2(cdf, x, lower, upper)
2075 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2076 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK2
2077 : #endif
2078 : use pm_kind, only: RKC => RK2
2079 : real(RKC) , intent(out) :: cdf
2080 : real(RKC) , intent(in) :: x
2081 : real(RKC) , intent(in) :: lower, upper
2082 : end subroutine
2083 : #endif
2084 :
2085 : #if RK1_ENABLED
2086 : PURE module subroutine setUnifCDF_LU_D0_RK1(cdf, x, lower, upper)
2087 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2088 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D0_RK1
2089 : #endif
2090 : use pm_kind, only: RKC => RK1
2091 : real(RKC) , intent(out) :: cdf
2092 : real(RKC) , intent(in) :: x
2093 : real(RKC) , intent(in) :: lower, upper
2094 : end subroutine
2095 : #endif
2096 :
2097 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2098 :
2099 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2100 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2101 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2102 :
2103 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2104 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2105 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2106 :
2107 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2108 :
2109 : #if RK5_ENABLED && IK5_ENABLED
2110 : PURE module subroutine setUnifCDF_LU_D1_RK5_IK5(cdf, X, lower, upper)
2111 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2112 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK5_IK5
2113 : #endif
2114 : use pm_kind, only: IKC => IK5, RKC => RK5
2115 : real(RKC) , intent(out) , contiguous :: cdf(:)
2116 : integer(IKC), intent(in) , contiguous :: X(:)
2117 : integer(IKC), intent(in) :: lower, upper
2118 : end subroutine
2119 : #endif
2120 :
2121 : #if RK4_ENABLED && IK5_ENABLED
2122 : PURE module subroutine setUnifCDF_LU_D1_RK4_IK5(cdf, X, lower, upper)
2123 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2124 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK4_IK5
2125 : #endif
2126 : use pm_kind, only: IKC => IK5, RKC => RK4
2127 : real(RKC) , intent(out) , contiguous :: cdf(:)
2128 : integer(IKC), intent(in) , contiguous :: X(:)
2129 : integer(IKC), intent(in) :: lower, upper
2130 : end subroutine
2131 : #endif
2132 :
2133 : #if RK3_ENABLED && IK5_ENABLED
2134 : PURE module subroutine setUnifCDF_LU_D1_RK3_IK5(cdf, X, lower, upper)
2135 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2136 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK3_IK5
2137 : #endif
2138 : use pm_kind, only: IKC => IK5, RKC => RK3
2139 : real(RKC) , intent(out) , contiguous :: cdf(:)
2140 : integer(IKC), intent(in) , contiguous :: X(:)
2141 : integer(IKC), intent(in) :: lower, upper
2142 : end subroutine
2143 : #endif
2144 :
2145 : #if RK2_ENABLED && IK5_ENABLED
2146 : PURE module subroutine setUnifCDF_LU_D1_RK2_IK5(cdf, X, lower, upper)
2147 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2148 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK2_IK5
2149 : #endif
2150 : use pm_kind, only: IKC => IK5, RKC => RK2
2151 : real(RKC) , intent(out) , contiguous :: cdf(:)
2152 : integer(IKC), intent(in) , contiguous :: X(:)
2153 : integer(IKC), intent(in) :: lower, upper
2154 : end subroutine
2155 : #endif
2156 :
2157 : #if RK1_ENABLED && IK5_ENABLED
2158 : PURE module subroutine setUnifCDF_LU_D1_RK1_IK5(cdf, X, lower, upper)
2159 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2160 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK1_IK5
2161 : #endif
2162 : use pm_kind, only: IKC => IK5, RKC => RK1
2163 : real(RKC) , intent(out) , contiguous :: cdf(:)
2164 : integer(IKC), intent(in) , contiguous :: X(:)
2165 : integer(IKC), intent(in) :: lower, upper
2166 : end subroutine
2167 : #endif
2168 :
2169 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2170 :
2171 : #if RK5_ENABLED && IK4_ENABLED
2172 : PURE module subroutine setUnifCDF_LU_D1_RK5_IK4(cdf, X, lower, upper)
2173 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2174 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK5_IK4
2175 : #endif
2176 : use pm_kind, only: IKC => IK4, RKC => RK5
2177 : real(RKC) , intent(out) , contiguous :: cdf(:)
2178 : integer(IKC), intent(in) , contiguous :: X(:)
2179 : integer(IKC), intent(in) :: lower, upper
2180 : end subroutine
2181 : #endif
2182 :
2183 : #if RK4_ENABLED && IK4_ENABLED
2184 : PURE module subroutine setUnifCDF_LU_D1_RK4_IK4(cdf, X, lower, upper)
2185 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2186 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK4_IK4
2187 : #endif
2188 : use pm_kind, only: IKC => IK4, RKC => RK4
2189 : real(RKC) , intent(out) , contiguous :: cdf(:)
2190 : integer(IKC), intent(in) , contiguous :: X(:)
2191 : integer(IKC), intent(in) :: lower, upper
2192 : end subroutine
2193 : #endif
2194 :
2195 : #if RK3_ENABLED && IK4_ENABLED
2196 : PURE module subroutine setUnifCDF_LU_D1_RK3_IK4(cdf, X, lower, upper)
2197 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2198 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK3_IK4
2199 : #endif
2200 : use pm_kind, only: IKC => IK4, RKC => RK3
2201 : real(RKC) , intent(out) , contiguous :: cdf(:)
2202 : integer(IKC), intent(in) , contiguous :: X(:)
2203 : integer(IKC), intent(in) :: lower, upper
2204 : end subroutine
2205 : #endif
2206 :
2207 : #if RK2_ENABLED && IK4_ENABLED
2208 : PURE module subroutine setUnifCDF_LU_D1_RK2_IK4(cdf, X, lower, upper)
2209 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2210 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK2_IK4
2211 : #endif
2212 : use pm_kind, only: IKC => IK4, RKC => RK2
2213 : real(RKC) , intent(out) , contiguous :: cdf(:)
2214 : integer(IKC), intent(in) , contiguous :: X(:)
2215 : integer(IKC), intent(in) :: lower, upper
2216 : end subroutine
2217 : #endif
2218 :
2219 : #if RK1_ENABLED && IK4_ENABLED
2220 : PURE module subroutine setUnifCDF_LU_D1_RK1_IK4(cdf, X, lower, upper)
2221 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2222 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK1_IK4
2223 : #endif
2224 : use pm_kind, only: IKC => IK4, RKC => RK1
2225 : real(RKC) , intent(out) , contiguous :: cdf(:)
2226 : integer(IKC), intent(in) , contiguous :: X(:)
2227 : integer(IKC), intent(in) :: lower, upper
2228 : end subroutine
2229 : #endif
2230 :
2231 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2232 :
2233 : #if RK5_ENABLED && IK3_ENABLED
2234 : PURE module subroutine setUnifCDF_LU_D1_RK5_IK3(cdf, X, lower, upper)
2235 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2236 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK5_IK3
2237 : #endif
2238 : use pm_kind, only: IKC => IK3, RKC => RK5
2239 : real(RKC) , intent(out) , contiguous :: cdf(:)
2240 : integer(IKC), intent(in) , contiguous :: X(:)
2241 : integer(IKC), intent(in) :: lower, upper
2242 : end subroutine
2243 : #endif
2244 :
2245 : #if RK4_ENABLED && IK3_ENABLED
2246 : PURE module subroutine setUnifCDF_LU_D1_RK4_IK3(cdf, X, lower, upper)
2247 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2248 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK4_IK3
2249 : #endif
2250 : use pm_kind, only: IKC => IK3, RKC => RK4
2251 : real(RKC) , intent(out) , contiguous :: cdf(:)
2252 : integer(IKC), intent(in) , contiguous :: X(:)
2253 : integer(IKC), intent(in) :: lower, upper
2254 : end subroutine
2255 : #endif
2256 :
2257 : #if RK3_ENABLED && IK3_ENABLED
2258 : PURE module subroutine setUnifCDF_LU_D1_RK3_IK3(cdf, X, lower, upper)
2259 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2260 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK3_IK3
2261 : #endif
2262 : use pm_kind, only: IKC => IK3, RKC => RK3
2263 : real(RKC) , intent(out) , contiguous :: cdf(:)
2264 : integer(IKC), intent(in) , contiguous :: X(:)
2265 : integer(IKC), intent(in) :: lower, upper
2266 : end subroutine
2267 : #endif
2268 :
2269 : #if RK2_ENABLED && IK3_ENABLED
2270 : PURE module subroutine setUnifCDF_LU_D1_RK2_IK3(cdf, X, lower, upper)
2271 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2272 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK2_IK3
2273 : #endif
2274 : use pm_kind, only: IKC => IK3, RKC => RK2
2275 : real(RKC) , intent(out) , contiguous :: cdf(:)
2276 : integer(IKC), intent(in) , contiguous :: X(:)
2277 : integer(IKC), intent(in) :: lower, upper
2278 : end subroutine
2279 : #endif
2280 :
2281 : #if RK1_ENABLED && IK3_ENABLED
2282 : PURE module subroutine setUnifCDF_LU_D1_RK1_IK3(cdf, X, lower, upper)
2283 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2284 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK1_IK3
2285 : #endif
2286 : use pm_kind, only: IKC => IK3, RKC => RK1
2287 : real(RKC) , intent(out) , contiguous :: cdf(:)
2288 : integer(IKC), intent(in) , contiguous :: X(:)
2289 : integer(IKC), intent(in) :: lower, upper
2290 : end subroutine
2291 : #endif
2292 :
2293 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2294 :
2295 : #if RK5_ENABLED && IK2_ENABLED
2296 : PURE module subroutine setUnifCDF_LU_D1_RK5_IK2(cdf, X, lower, upper)
2297 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2298 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK5_IK2
2299 : #endif
2300 : use pm_kind, only: IKC => IK2, RKC => RK5
2301 : real(RKC) , intent(out) , contiguous :: cdf(:)
2302 : integer(IKC), intent(in) , contiguous :: X(:)
2303 : integer(IKC), intent(in) :: lower, upper
2304 : end subroutine
2305 : #endif
2306 :
2307 : #if RK4_ENABLED && IK2_ENABLED
2308 : PURE module subroutine setUnifCDF_LU_D1_RK4_IK2(cdf, X, lower, upper)
2309 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2310 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK4_IK2
2311 : #endif
2312 : use pm_kind, only: IKC => IK2, RKC => RK4
2313 : real(RKC) , intent(out) , contiguous :: cdf(:)
2314 : integer(IKC), intent(in) , contiguous :: X(:)
2315 : integer(IKC), intent(in) :: lower, upper
2316 : end subroutine
2317 : #endif
2318 :
2319 : #if RK3_ENABLED && IK2_ENABLED
2320 : PURE module subroutine setUnifCDF_LU_D1_RK3_IK2(cdf, X, lower, upper)
2321 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2322 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK3_IK2
2323 : #endif
2324 : use pm_kind, only: IKC => IK2, RKC => RK3
2325 : real(RKC) , intent(out) , contiguous :: cdf(:)
2326 : integer(IKC), intent(in) , contiguous :: X(:)
2327 : integer(IKC), intent(in) :: lower, upper
2328 : end subroutine
2329 : #endif
2330 :
2331 : #if RK2_ENABLED && IK2_ENABLED
2332 : PURE module subroutine setUnifCDF_LU_D1_RK2_IK2(cdf, X, lower, upper)
2333 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2334 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK2_IK2
2335 : #endif
2336 : use pm_kind, only: IKC => IK2, RKC => RK2
2337 : real(RKC) , intent(out) , contiguous :: cdf(:)
2338 : integer(IKC), intent(in) , contiguous :: X(:)
2339 : integer(IKC), intent(in) :: lower, upper
2340 : end subroutine
2341 : #endif
2342 :
2343 : #if RK1_ENABLED && IK2_ENABLED
2344 : PURE module subroutine setUnifCDF_LU_D1_RK1_IK2(cdf, X, lower, upper)
2345 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2346 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK1_IK2
2347 : #endif
2348 : use pm_kind, only: IKC => IK2, RKC => RK1
2349 : real(RKC) , intent(out) , contiguous :: cdf(:)
2350 : integer(IKC), intent(in) , contiguous :: X(:)
2351 : integer(IKC), intent(in) :: lower, upper
2352 : end subroutine
2353 : #endif
2354 :
2355 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2356 :
2357 : #if RK5_ENABLED && IK1_ENABLED
2358 : PURE module subroutine setUnifCDF_LU_D1_RK5_IK1(cdf, X, lower, upper)
2359 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2360 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK5_IK1
2361 : #endif
2362 : use pm_kind, only: IKC => IK1, RKC => RK5
2363 : real(RKC) , intent(out) , contiguous :: cdf(:)
2364 : integer(IKC), intent(in) , contiguous :: X(:)
2365 : integer(IKC), intent(in) :: lower, upper
2366 : end subroutine
2367 : #endif
2368 :
2369 : #if RK4_ENABLED && IK1_ENABLED
2370 : PURE module subroutine setUnifCDF_LU_D1_RK4_IK1(cdf, X, lower, upper)
2371 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2372 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK4_IK1
2373 : #endif
2374 : use pm_kind, only: IKC => IK1, RKC => RK4
2375 : real(RKC) , intent(out) , contiguous :: cdf(:)
2376 : integer(IKC), intent(in) , contiguous :: X(:)
2377 : integer(IKC), intent(in) :: lower, upper
2378 : end subroutine
2379 : #endif
2380 :
2381 : #if RK3_ENABLED && IK1_ENABLED
2382 : PURE module subroutine setUnifCDF_LU_D1_RK3_IK1(cdf, X, lower, upper)
2383 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2384 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK3_IK1
2385 : #endif
2386 : use pm_kind, only: IKC => IK1, RKC => RK3
2387 : real(RKC) , intent(out) , contiguous :: cdf(:)
2388 : integer(IKC), intent(in) , contiguous :: X(:)
2389 : integer(IKC), intent(in) :: lower, upper
2390 : end subroutine
2391 : #endif
2392 :
2393 : #if RK2_ENABLED && IK1_ENABLED
2394 : PURE module subroutine setUnifCDF_LU_D1_RK2_IK1(cdf, X, lower, upper)
2395 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2396 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK2_IK1
2397 : #endif
2398 : use pm_kind, only: IKC => IK1, RKC => RK2
2399 : real(RKC) , intent(out) , contiguous :: cdf(:)
2400 : integer(IKC), intent(in) , contiguous :: X(:)
2401 : integer(IKC), intent(in) :: lower, upper
2402 : end subroutine
2403 : #endif
2404 :
2405 : #if RK1_ENABLED && IK1_ENABLED
2406 : PURE module subroutine setUnifCDF_LU_D1_RK1_IK1(cdf, X, lower, upper)
2407 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2408 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK1_IK1
2409 : #endif
2410 : use pm_kind, only: IKC => IK1, RKC => RK1
2411 : real(RKC) , intent(out) , contiguous :: cdf(:)
2412 : integer(IKC), intent(in) , contiguous :: X(:)
2413 : integer(IKC), intent(in) :: lower, upper
2414 : end subroutine
2415 : #endif
2416 :
2417 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2418 :
2419 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2420 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2421 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2422 :
2423 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2424 :
2425 : #if CK5_ENABLED
2426 : PURE module subroutine setUnifCDF_LU_D1_CK5(cdf, X, lower, upper)
2427 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2428 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_CK5
2429 : #endif
2430 : use pm_kind, only: CKC => CK5
2431 : complex(CKC), intent(out) , contiguous :: cdf(:)
2432 : complex(CKC), intent(in) , contiguous :: X(:)
2433 : complex(CKC), intent(in) :: lower, upper
2434 : end subroutine
2435 : #endif
2436 :
2437 : #if CK4_ENABLED
2438 : PURE module subroutine setUnifCDF_LU_D1_CK4(cdf, X, lower, upper)
2439 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2440 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_CK4
2441 : #endif
2442 : use pm_kind, only: CKC => CK4
2443 : complex(CKC), intent(out) , contiguous :: cdf(:)
2444 : complex(CKC), intent(in) , contiguous :: X(:)
2445 : complex(CKC), intent(in) :: lower, upper
2446 : end subroutine
2447 : #endif
2448 :
2449 : #if CK3_ENABLED
2450 : PURE module subroutine setUnifCDF_LU_D1_CK3(cdf, X, lower, upper)
2451 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2452 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_CK3
2453 : #endif
2454 : use pm_kind, only: CKC => CK3
2455 : complex(CKC), intent(out) , contiguous :: cdf(:)
2456 : complex(CKC), intent(in) , contiguous :: X(:)
2457 : complex(CKC), intent(in) :: lower, upper
2458 : end subroutine
2459 : #endif
2460 :
2461 : #if CK2_ENABLED
2462 : PURE module subroutine setUnifCDF_LU_D1_CK2(cdf, X, lower, upper)
2463 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2464 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_CK2
2465 : #endif
2466 : use pm_kind, only: CKC => CK2
2467 : complex(CKC), intent(out) , contiguous :: cdf(:)
2468 : complex(CKC), intent(in) , contiguous :: X(:)
2469 : complex(CKC), intent(in) :: lower, upper
2470 : end subroutine
2471 : #endif
2472 :
2473 : #if CK1_ENABLED
2474 : PURE module subroutine setUnifCDF_LU_D1_CK1(cdf, X, lower, upper)
2475 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2476 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_CK1
2477 : #endif
2478 : use pm_kind, only: CKC => CK1
2479 : complex(CKC), intent(out) , contiguous :: cdf(:)
2480 : complex(CKC), intent(in) , contiguous :: X(:)
2481 : complex(CKC), intent(in) :: lower, upper
2482 : end subroutine
2483 : #endif
2484 :
2485 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2486 :
2487 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2488 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2489 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2490 :
2491 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2492 :
2493 : #if RK5_ENABLED
2494 : PURE module subroutine setUnifCDF_LU_D1_RK5(cdf, X, lower, upper)
2495 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2496 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK5
2497 : #endif
2498 : use pm_kind, only: RKC => RK5
2499 : real(RKC) , intent(out) , contiguous :: cdf(:)
2500 : real(RKC) , intent(in) , contiguous :: X(:)
2501 : real(RKC) , intent(in) :: lower, upper
2502 : end subroutine
2503 : #endif
2504 :
2505 : #if RK4_ENABLED
2506 : PURE module subroutine setUnifCDF_LU_D1_RK4(cdf, X, lower, upper)
2507 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2508 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK4
2509 : #endif
2510 : use pm_kind, only: RKC => RK4
2511 : real(RKC) , intent(out) , contiguous :: cdf(:)
2512 : real(RKC) , intent(in) , contiguous :: X(:)
2513 : real(RKC) , intent(in) :: lower, upper
2514 : end subroutine
2515 : #endif
2516 :
2517 : #if RK3_ENABLED
2518 : PURE module subroutine setUnifCDF_LU_D1_RK3(cdf, X, lower, upper)
2519 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2520 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK3
2521 : #endif
2522 : use pm_kind, only: RKC => RK3
2523 : real(RKC) , intent(out) , contiguous :: cdf(:)
2524 : real(RKC) , intent(in) , contiguous :: X(:)
2525 : real(RKC) , intent(in) :: lower, upper
2526 : end subroutine
2527 : #endif
2528 :
2529 : #if RK2_ENABLED
2530 : PURE module subroutine setUnifCDF_LU_D1_RK2(cdf, X, lower, upper)
2531 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2532 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK2
2533 : #endif
2534 : use pm_kind, only: RKC => RK2
2535 : real(RKC) , intent(out) , contiguous :: cdf(:)
2536 : real(RKC) , intent(in) , contiguous :: X(:)
2537 : real(RKC) , intent(in) :: lower, upper
2538 : end subroutine
2539 : #endif
2540 :
2541 : #if RK1_ENABLED
2542 : PURE module subroutine setUnifCDF_LU_D1_RK1(cdf, X, lower, upper)
2543 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2544 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifCDF_LU_D1_RK1
2545 : #endif
2546 : use pm_kind, only: RKC => RK1
2547 : real(RKC) , intent(out) , contiguous :: cdf(:)
2548 : real(RKC) , intent(in) , contiguous :: X(:)
2549 : real(RKC) , intent(in) :: lower, upper
2550 : end subroutine
2551 : #endif
2552 :
2553 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2554 :
2555 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2556 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2557 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2558 :
2559 : end interface
2560 :
2561 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2562 :
2563 : !> \brief
2564 : !> The constant scalar of type `integer` of default kind containing
2565 : !> the number of binary digits of the `stream` component [Xoshiro256**](https://prng.di.unimi.it/) random number generator.<br>
2566 : !>
2567 : !> \details
2568 : !> By definition, this number is `64`, because the type kind parameter of `stream` is \IK64.<br>
2569 : !>
2570 : !> \see
2571 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2572 : !> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128)<br>
2573 : !> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192)<br>
2574 : !> [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw)<br>
2575 : !> [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize)<br>
2576 : !>
2577 : !> \finmain{xoshiro256ssStateSize}
2578 : !>
2579 : !> \author
2580 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
2581 : integer(IK) , parameter :: xoshiro256ssStreamBitSize = int(bit_size(0_IK64), IK)
2582 :
2583 : !> \brief
2584 : !> The constant scalar of type `integer` of default kind \IK containing
2585 : !> the size of the state vector of [Xoshiro256**](https://prng.di.unimi.it/) random number generator.<br>
2586 : !>
2587 : !> \details
2588 : !> For more information see the documentation of
2589 : !> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) and
2590 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type).<br>
2591 : !>
2592 : !> \see
2593 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2594 : !> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128)<br>
2595 : !> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192)<br>
2596 : !> [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw)<br>
2597 : !> [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize)<br>
2598 : !>
2599 : !> \finmain{xoshiro256ssStateSize}
2600 : !>
2601 : !> \author
2602 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
2603 : integer(IK) , parameter :: xoshiro256ssStateSize = 4_IK
2604 :
2605 : !> \brief
2606 : !> The constant vector of size [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize)
2607 : !> of type `integer` of kind \IK64 containing the state jump for the
2608 : !> [Xoshiro256**](https://prng.di.unimi.it/) random number generator.<br>
2609 : !>
2610 : !> \details
2611 : !> This state jump can be passed to the constructor of [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) to request an RNG
2612 : !> whose state starts at `imageID * 2**128` steps (i.e., random number generations) ahead of the RNG constructed with `imageID = 1`.<br>
2613 : !> Using this jump, one can generate `2**128` independent RNG sequences each of which has a period of `2**128` in parallel applications.<br>
2614 : !> For more information see the documentation of
2615 : !> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) and
2616 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type).<br>
2617 : !>
2618 : !> The elements of this constant vector are obtained by transferring the following unsigned integers to signed values.<br>
2619 : !> \code{.F90}
2620 : !> integer(IK64) , parameter :: xoshiro256ssJump128(xoshiro256ssStateSize) = [ transfer(Z"180ec6d33cfd0aba", 0_IK64) &
2621 : !> , transfer(Z"d5a61266f0c9392c", 0_IK64) &
2622 : !> , transfer(Z"a9582618e03fc9aa", 0_IK64) &
2623 : !> , transfer(Z"39abdc4529b1661c", 0_IK64) ]
2624 : !> \endcode
2625 : !>
2626 : !> \see
2627 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2628 : !> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128)<br>
2629 : !> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192)<br>
2630 : !> [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw)<br>
2631 : !> [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize)<br>
2632 : !>
2633 : !> \finmain{xoshiro256ssJump128}
2634 : !>
2635 : !> \author
2636 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
2637 : integer(IK64) , parameter :: xoshiro256ssJump128(xoshiro256ssStateSize) = [ +1733541517147835066_IK64 &
2638 : , -3051731464161248980_IK64 &
2639 : , -6244198995065845334_IK64 &
2640 : , +4155657270789760540_IK64 ]
2641 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2642 : !DIR$ ATTRIBUTES DLLEXPORT :: xoshiro256ssJump128
2643 : #endif
2644 :
2645 : !> \brief
2646 : !> The constant vector of size [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize)
2647 : !> of type `integer` of kind \IK64 containing the state jump for the
2648 : !> [Xoshiro256**](https://prng.di.unimi.it/) random number generator.<br>
2649 : !>
2650 : !> \details
2651 : !> This state jump can be passed to the constructor of [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) to request an RNG
2652 : !> whose state starts at `imageID * 2**192` steps (i.e., random number generations) ahead of the RNG constructed with `imageID = 1`.<br>
2653 : !> Using this jump, one can generate `2**64` independent RNG sequences each of which has a period of `2**192` in parallel applications.<br>
2654 : !> For more information see the documentation of
2655 : !> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) and
2656 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type).<br>
2657 : !>
2658 : !> The elements of this constant vector are obtained by transferring the following unsigned integers to signed values.<br>
2659 : !> \code{.F90}
2660 : !> integer(IK64) , parameter :: xoshiro256ssJump192(xoshiro256ssStateSize) = [ transfer(Z"76e15d3efefdcbbf", 0_IK64) &
2661 : !> , transfer(Z"c5004e441c522fb3", 0_IK64) &
2662 : !> , transfer(Z"77710069854ee241", 0_IK64) &
2663 : !> , transfer(Z"39109bb02acbe635", 0_IK64) ]
2664 : !> \endcode
2665 : !>
2666 : !> \see
2667 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2668 : !> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128)<br>
2669 : !> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192)<br>
2670 : !> [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw)<br>
2671 : !> [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize)<br>
2672 : !>
2673 : !> \finmain{xoshiro256ssJump192}
2674 : !>
2675 : !> \author
2676 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
2677 : integer(IK64) , parameter :: xoshiro256ssJump192(xoshiro256ssStateSize) = [ +8566230491382795199_IK64 &
2678 : , -4251311993797857357_IK64 &
2679 : , +8606660816089834049_IK64 &
2680 : , +4111957640723818037_IK64 ]
2681 :
2682 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2683 :
2684 : !> \brief
2685 : !> This is the `abstract` base derived type for defining various Uniform Random Number Generator (URNG) derived types.<br>
2686 : !>
2687 : !> \see
2688 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
2689 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
2690 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
2691 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2692 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
2693 : !>
2694 : !> \test
2695 : !> [test_pm_distUnif](@ref test_pm_distUnif)
2696 : !>
2697 : !> \finmain{rngu_type}
2698 : !>
2699 : !> \author
2700 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
2701 : type, abstract :: rngu_type
2702 : end type
2703 :
2704 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2705 :
2706 : !> \brief
2707 : !> This is a concrete derived type whose instances can be used to define/request
2708 : !> the default uniform random number generator (**RNG**) of the Fortran standard.<br>
2709 : !>
2710 : !> \details
2711 : !> This type does not currently hold any components.<br>
2712 : !> It is merely used to signal/request the use of the intrinsic Fortran RNG.<br>
2713 : !> The Fortran programming language offers a single mechanism through the intrinsic procedure `random_seed(size = size, put = put, get = get)`
2714 : !> to set the seed of the intrinsic uniform random number generator of Fortran `random_number(harvest)`.<br>
2715 : !> However, the internal implementation of the random number generator can vary from compiler to another.<br>
2716 : !> Furthermore, the size and requirements for the initial state (seed) can be also different across compilers.<br>
2717 : !> As such, Fortran programming language also offers a new intrinsic procedure `random_init(repeatable, image_distinct)`.
2718 : !> <ol>
2719 : !> <li> If `repeatable = .true.`, the seed is set to the same processor-dependent value
2720 : !> each time `random_init(repeatable = .true., ...)` is called from the same image.<br>
2721 : !> The program is, therefore, guaranteed to generate the same random number sequence after each call to `random_init()`.<br>
2722 : !> The term *same image* means a *single instance of program execution*.<br>
2723 : !> The sequence of random numbers is *different for repeated execution* of the program.<br>
2724 : !> If it is `.false.`, the seed is set to a processor-dependent value.<br>
2725 : !> <li> If `image_distinct = .true.`, the seed is set to a processor-dependent value that is
2726 : !> distinct from th seed set by a call to `random_init()` in another (Coarray) image.<br>
2727 : !> If it is `image_distinct = .false.`, the seed is set to a value that does **not** depend which image called `random_init()`.<br>
2728 : !> </ol>
2729 : !> The Fortran intrinsic `random_init()` apparently does guarantee the generation
2730 : !> of the same random sequence in multiple independent executions of the program.<br>
2731 : !> This requires setting the RNG seed explicitly at the beginning of each program execution.<br>
2732 : !>
2733 : !> The [rngf_type](@ref pm_distUnif::rngf_type) aims to facilitate the above
2734 : !> goal by offering a single interface that combines `random_init()` and `random_seed()` intrinsic routines.<br>
2735 : !>
2736 : !> \param[in] seed : The input scalar of type `integer` of default kind \IK,
2737 : !> containing a positive integer that serves as the starting point to generate the full RNG seed.<br>
2738 : !> Specify this input argument if you wish to make random simulations reproducible,
2739 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
2740 : !> (**optional**. If missing, it is set to a value determined by the current date and time.)
2741 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
2742 : !> This can be,
2743 : !> <ol>
2744 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
2745 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
2746 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
2747 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
2748 : !> </ol>
2749 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
2750 : !> This number will be used to set the RNG seed uniquely on each processor.<br>
2751 : !> (**optional**. If missing, the RNG seed will be set identically on all images.)
2752 : !>
2753 : !> \return
2754 : !> `rng` : The output scalar object of type [rngf_type](@ref pm_distUnif::rngf_type).<br>
2755 : !>
2756 : !> \interface{rngf_type}
2757 : !> \code{.F90}
2758 : !>
2759 : !> use pm_kind, only: IK
2760 : !> use pm_distUnif, only: rngf_type
2761 : !> type(rngf_type) :: rng
2762 : !>
2763 : !> rng = rngf_type(seed = seed, imageID = imageID)
2764 : !> print *, getUnifRandState()
2765 : !>
2766 : !> \endcode
2767 : !>
2768 : !> \note
2769 : !> This generic interface does not aim to replicate the behavior of the Fortran intrinsic `random_init()` but rather to extend it.<br>
2770 : !> If you wish to reset the RNG seed to a reproducible seed without specifying a scalar reference value for it via this generic interface,
2771 : !> simply call `random_init(repeatable = .true., ...)`.<br>
2772 : !> However, unlike `random_init()`, this generic interface can guarantee reproducibility of RNG sequences within
2773 : !> and between multiple program runs in serial or parallel Coarray/MPI/OpenMP, all compiled by the same compiler.<br>
2774 : !>
2775 : !> \see
2776 : !> [rngf](@ref pm_distUnif::rngf)<br>
2777 : !> [isHead](@ref pm_distBern::isHead)<br>
2778 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
2779 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
2780 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
2781 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
2782 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
2783 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
2784 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
2785 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
2786 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2787 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
2788 : !>
2789 : !> \example{rngf_type}
2790 : !> \include{lineno} example/pm_distUnif/rngf_type/main.F90
2791 : !> \compilef{rngf_type}
2792 : !> \output{rngf_type}
2793 : !> \include{lineno} example/pm_distUnif/rngf_type/main.out.F90
2794 : !>
2795 : !> \finmain{rngf_type}
2796 : !>
2797 : !> \author
2798 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2799 : type, extends(rngu_type) :: rngf_type
2800 : end type
2801 :
2802 : !> \brief
2803 : !> The scalar constant object of type [rngf_type](@ref pm_distUnif::rngf_type)
2804 : !> whose presence signified the use of the Fortran intrinsic random number generator (RNGF).<br>
2805 : !>
2806 : !> \details
2807 : !> This constant is merely a convenience for making easier calls to routines that require a default RNGF.<br>
2808 : !>
2809 : !> \interface{rngf}
2810 : !> \code{.F90}
2811 : !>
2812 : !> use pm_distUnif, only: rngf, rngf_type
2813 : !> type(rngf_type) :: rng = rngf
2814 : !>
2815 : !> \endcode
2816 : !>
2817 : !> \see
2818 : !> [rngf](@ref pm_distUnif::rngf)<br>
2819 : !> [isHead](@ref pm_distBern::isHead)<br>
2820 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
2821 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
2822 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
2823 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
2824 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
2825 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
2826 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
2827 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
2828 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2829 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
2830 : !>
2831 : !> \bug
2832 : !> \status \unresolved
2833 : !> \source \ifort{2021.8.0 20221119}
2834 : !> \desc
2835 : !> \ifort cannot handle the creation of a module constant of type [rngf_type](@ref pm_distUnif::rngf_type) as done for this object,
2836 : !> yielding the following error.<br>
2837 : !> \code{.sh}
2838 : !> error #9066: A generic function reference is not permitted in a constant expression. [CONSTRUCTFRNG]
2839 : !> \endcode
2840 : !> GNU compiler compiles and runs the code without complaining.<br>
2841 : !> \remedy{2.0.0}
2842 : !> For now, the `parameter` attribute is removed from the declaration of [rngf](@ref pm_distUnif::rngf).<br>
2843 : !>
2844 : !> \finmain{rngf}
2845 : !>
2846 : !> \author
2847 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2848 : type(rngf_type) :: rngf! = rngf_type()
2849 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2850 : !DIR$ ATTRIBUTES DLLEXPORT :: rngf
2851 : #endif
2852 :
2853 : !> \cond excluded
2854 : interface rngf_type
2855 : module procedure :: constructFRNG
2856 : end interface
2857 : !> \endcond excluded
2858 :
2859 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2860 :
2861 : !> \brief
2862 : !> Generate and return a scalar object of type [rngf_type](@ref pm_distUnif::rngf_type).
2863 : !>
2864 : !> \details
2865 : !> This generic interface is the constructor of [rngf_type](@ref pm_distUnif::rngf_type).<br>
2866 : !> See the documentation of [rngf_type](@ref pm_distUnif::rngf_type) for example usage and interface.
2867 : !>
2868 : !> \impure
2869 : !>
2870 : !> \see
2871 : !> [rngf](@ref pm_distUnif::rngf)<br>
2872 : !> [isHead](@ref pm_distBern::isHead)<br>
2873 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
2874 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
2875 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
2876 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
2877 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
2878 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
2879 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
2880 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
2881 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2882 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
2883 : !>
2884 : !> \test
2885 : !> [test_pm_distUnif](@ref test_pm_distUnif)
2886 : !>
2887 : !> \finmain{constructFRNG}
2888 : !>
2889 : !> \author
2890 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2891 : interface constructFRNG
2892 : module function constructFRNG(seed, imageID) result(self)
2893 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2894 : !DEC$ ATTRIBUTES DLLEXPORT :: constructFRNG
2895 : #endif
2896 : integer(IK) , intent(in), optional :: seed, imageID
2897 : type(rngf_type) :: self
2898 : end function
2899 : end interface
2900 :
2901 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2902 :
2903 : !> \brief
2904 : !> This is the `abstract` base derived type for defining variants of
2905 : !> [Xoshiro256**](https://prng.di.unimi.it/) Uniform Random Number Generator derived types.<br>
2906 : !>
2907 : !> \see
2908 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
2909 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
2910 : !> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type)<br>
2911 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
2912 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
2913 : !>
2914 : !> \benchmarks
2915 : !>
2916 : !> \benchmark{xoshiro256ss_type, The runtime performance of intrinsic `random_number()` vs. [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) vs. [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type).}
2917 : !> \include{lineno} benchmark/pm_distUnif/xoshiro256ss_type/main.F90
2918 : !> \compilefb{xoshiro256ss_type}
2919 : !> \postprocb{xoshiro256ss_type}
2920 : !> \include{lineno} benchmark/pm_distUnif/xoshiro256ss_type/main.py
2921 : !> \visb{xoshiro256ss_type}
2922 : !> \image html benchmark/pm_distUnif/xoshiro256ss_type/benchmark.xoshiro256ss_type.runtime.png width=1000
2923 : !> \image html benchmark/pm_distUnif/xoshiro256ss_type/benchmark.xoshiro256ss_type.runtime.ratio.png width=1000
2924 : !> \moralb{xoshiro256ss_type}
2925 : !> -# The [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) RNG
2926 : !> greedily attempts to use as many randomly generated bits as possible in the output random values.<br>
2927 : !> -# The [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) RNG
2928 : !> takes a wasteful approach of using at least one or more chunks of 64 randomly generated bits in the output random values.<br>
2929 : !> -# This fundamental difference between the two RNG types generally leads to faster random logical value generations with
2930 : !> the greedy approach, because 64bits chunks translate to 64 logical values without updating the RNG state.<br>
2931 : !> -# However, the greedy approach leads to generally slower runtimes for real random value generation.<br>
2932 : !> -# Both greedy and wasteful RNGs appear to be much faster than the ParaMonte
2933 : !> library wrappers for the implementations offered by \gfortran and \ifort.<br>
2934 : !> -# <b>Moral</b>: If your application requires many `logical` random number generations,
2935 : !> use the greedy [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) RNG.
2936 : !> Conversely, if your application requires a mixture of random number generations of various types and kinds,
2937 : !> use the wasteful [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) RNG.
2938 : !>
2939 : !> \test
2940 : !> [test_pm_distUnif](@ref test_pm_distUnif)
2941 : !>
2942 : !> \finmain{xoshiro256ss_type}
2943 : !>
2944 : !> \author
2945 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
2946 : type, abstract, extends(rngu_type) :: xoshiro256ss_type
2947 : !> \brief
2948 : !> The vector of size [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize)
2949 : !> of type `integer` of kind \IK64, containing the most recent RNG state.<br>
2950 : integer(IK64) :: state(xoshiro256ssStateSize) = [ -5952639272145821898_IK64 &
2951 : , -2790978430781836137_IK64 &
2952 : , -4872796757339724681_IK64 &
2953 : , -6638731986642513151_IK64 ]
2954 : !> \brief
2955 : !> The scalar of type `integer` of kind \IK64, containing the most recently generated random 64-bit stream.
2956 : integer(IK64) :: stream
2957 : end type
2958 :
2959 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2960 :
2961 : !> \brief
2962 : !> This is the derived type for declaring and generating objects of type [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)
2963 : !> containing a unique instance of a [Xoshiro256**](https://prng.di.unimi.it/) random number generator (RNG).
2964 : !>
2965 : !> \details
2966 : !> See also the documentation of [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw) for information on the constructor of this type.<br>
2967 : !>
2968 : !> Xorshift random number generators, also called **shift-register generators**, are a class of pseudorandom
2969 : !> number generators that were invented by [George Marsaglia](https://en.wikipedia.org/wiki/George_Marsaglia).<br>
2970 : !> They are a subset of linear-feedback shift registers (LFSRs) which allow a particularly
2971 : !> efficient implementation in software without the excessive use of sparse polynomials.<br>
2972 : !> They generate the next number in their sequence by repeatedly taking the Exclusive OR (XOR)
2973 : !> of a number with a bit-shifted version of itself.<br>
2974 : !> This makes execution extremely efficient on modern computer architectures,
2975 : !> although it does not benefit efficiency in a hardware implementation.<br>
2976 : !> Like all LFSRs, the parameters have to be chosen very carefully in order to achieve a long period.<br>
2977 : !>
2978 : !> The [xoshiro256**](https://prng.di.unimi.it/) RNG implemented in this derived type
2979 : !> is a subclass of Xorshift RNGs developed by David Blackman and Sebastiano Vigna.<br>
2980 : !> It is a 64-bit RNG that uses a carefully constructed linear transformation combined with shifts and rotations.<br>
2981 : !> This produces a computationally fast RNG with claimed excellent statistical qualities.<br>
2982 : !> Xoshiro256 has a period of \f$2^{256} - 1\f$ and and supports jumping the sequence in increments of \f$2^128\f$ and \f$2^192\f$.<br>
2983 : !> This allows the creation of many non-overlapping RNG subsequences for parallel applications.<br>
2984 : !>
2985 : !> <b>xoshiro256** random seed</b>
2986 : !> The [xoshiro256**](https://prng.di.unimi.it/) state is determined by a vector of size
2987 : !> [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize) of type `integer` of kind \IK64.<br>
2988 : !> The RNG seed of [xoshiro256**](https://prng.di.unimi.it/) in this module is initialized based on either a user-specified scalar
2989 : !> initial seed value or an internal processor-dependent value based on the system clock.<br>
2990 : !> In either case, the seed is used as an input for another simple random number generator [splitMix64](@ref pm_distUnif::splitmix64_type)
2991 : !> and the output of this RNG is used as the initial state of [xoshiro256**](https://prng.di.unimi.it/).<br>
2992 : !>
2993 : !> <b>Parallel applications</b>
2994 : !> [xoshiro256**](https://prng.di.unimi.it/) has a period of \f$2^{256} - 1\f$ and and supports jumping the sequence in increments of \f$2^128\f$ and \f$2^192\f$.<br>
2995 : !> This allows the creation of many non-overlapping RNG subsequences for parallel applications.<br>
2996 : !> [xoshiro256**](https://prng.di.unimi.it/) can be used in parallel applications by passing the `imageID` of the current processor to the RNG constructor.<br>
2997 : !> By default, the RNG constructor makes jumps of size `2**128` in the RRNG sequence to initialize subsequent RNGs on different processors.<br>
2998 : !> While such jump size is more than enough for any practical applications in modern days, the future galactic humans can request longer jumps
2999 : !> of size `2**192` by passing the non-default longer jump vector [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192) to the
3000 : !> constructor of the RNG.<br>
3001 : !> In either case, all RNGs on different processors must be initialized with the same original seed and jump vector (but with different processor
3002 : !> IDs set by the `imageID` argument to the RNG constructor) to ensure that the individual RNG sequences on different processors do not overlap.
3003 : !>
3004 : !> <b>Usage instructions</b>
3005 : !> This derived type contains only the most recently updated state and random bit stream of the RNG.<br>
3006 : !> To generate random values of arbitrary intrinsic kinds (`character`, `integer`, `logical`, `complex`, `real`)
3007 : !> the user must,<br>
3008 : !> <ol>
3009 : !> <li> declare an object of type [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) and
3010 : !> initialize the object via the type constructor [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw)
3011 : !> (see below for the possible calling interfaces),
3012 : !> <li> pass the generated RNG instance to the desired random number generating routines,
3013 : !> <ol>
3014 : !> <li> [getUnifRand](@ref pm_distUnif::getUnifRand),
3015 : !> <li> [setUnifRand](@ref pm_distUnif::setUnifRand),
3016 : !> </ol>
3017 : !> to generate the desired scalar or sequence of random values.<br>
3018 : !> </ol>
3019 : !>
3020 : !> \param[in] seed : The input scalar of type `integer` of kind \IK64,
3021 : !> containing an integer that serves as the starting point to generate the full deterministic RNG seed.<br>
3022 : !> Specify this input argument if you wish to make random simulations reproducible and deterministic,
3023 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
3024 : !> (**optional**. If missing, it is set to a processor-dependent value based on the current date and time.)
3025 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
3026 : !> This can be,
3027 : !> <ol>
3028 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
3029 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
3030 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
3031 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
3032 : !> </ol>
3033 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
3034 : !> This number will be used to set the RNG seed uniquely on each processor.<br>
3035 : !> (**optional**. If missing, the RNG seed will be set as if it is called in a serial application (or called on the first image).)
3036 : !> \param[in] jump : The input vector of size [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize) of type `integer` of kind \IK64,
3037 : !> whose value sets the jump size of the random number generator.<br>
3038 : !> It can be,
3039 : !> <ol>
3040 : !> <li> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128), corresponding to a jump size of `imageID * 2**128`.<br>
3041 : !> This jump can be used to generate up to `2**128` unique RNG sequences in parallel, each with length `2**128`.<br>
3042 : !> <li> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192), corresponding to a jump size of `imageID * 2**192`.<br>
3043 : !> This jump can be used to generate up to `2**64` unique RNG sequences in parallel, each with length `2**192`.<br>
3044 : !> </ol>
3045 : !> (**optional**. default = [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128))
3046 : !>
3047 : !> \return
3048 : !> `rng` : The output scalar object (or array of objects, of the same rank and shape as the input array-like arguments)
3049 : !> of type [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) containing an instance of a splitmix64
3050 : !> random number generator.<br>
3051 : !>
3052 : !> \interface{xoshiro256ssw_type}
3053 : !> \code{.F90}
3054 : !>
3055 : !> use pm_kind, only: IK
3056 : !> use pm_distUnif, only: xoshiro256ssw_type
3057 : !> type(xoshiro256ssw_type) :: rng
3058 : !>
3059 : !> rng = xoshiro256ssw_type(seed = seed, imageID = imageID, jump = jump)
3060 : !> rand = getUnifRand(rng, rand, lb, ub)
3061 : !> call setUnifRand(rng, rand, lb, ub)
3062 : !> call setUnifRand(rng, rand)
3063 : !>
3064 : !> \endcode
3065 : !>
3066 : !> \warning
3067 : !> The condition `0 < imageID` must hold for the corresponding input arguments.<br>
3068 : !> \vericon
3069 : !>
3070 : !> \warning
3071 : !> Although the components of this derived type are `public`, they are theoretically `protected`.<br>
3072 : !> The end users must not manipulate the component values at any stages of the random number generation.<br>
3073 : !>
3074 : !> \note
3075 : !> Without initializing objects of this derived type, the generated RNGs will always be deterministic,
3076 : !> always yielding identical sequences.<br>
3077 : !>
3078 : !> \see
3079 : !> [rngf](@ref pm_distUnif::rngf)<br>
3080 : !> [isHead](@ref pm_distBern::isHead)<br>
3081 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3082 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3083 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3084 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3085 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3086 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
3087 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
3088 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
3089 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
3090 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3091 : !>
3092 : !> \example{xoshiro256ssw_type}
3093 : !> \include{lineno} example/pm_distUnif/xoshiro256ssw_type/main.F90
3094 : !> \compilef{xoshiro256ssw_type}
3095 : !> \output{xoshiro256ssw_type}
3096 : !> \include{lineno} example/pm_distUnif/xoshiro256ssw_type/main.out.F90
3097 : !> \postproc{xoshiro256ssw_type}
3098 : !> \include{lineno} example/pm_distUnif/xoshiro256ssw_type/main.py
3099 : !> \vis{xoshiro256ssw_type}
3100 : !> \image html pm_distUnif/xoshiro256ssw_type/xoshiro256ssw_type.IK.png width=700
3101 : !> \image html pm_distUnif/xoshiro256ssw_type/xoshiro256ssw_type.CK.png width=700
3102 : !> \image html pm_distUnif/xoshiro256ssw_type/xoshiro256ssw_type.RK.png width=700
3103 : !>
3104 : !> \test
3105 : !> [test_pm_distUnif](@ref test_pm_distUnif)
3106 : !>
3107 : !> \todo
3108 : !> \phigh
3109 : !> An illustration of the distribution of the probability of individual bits being `0` or `1` in the
3110 : !> mantissa of `real`-valued random numbers and `integer` random numbers must be added to the example.<br>
3111 : !>
3112 : !> \finmain{xoshiro256ssw_type}
3113 : !>
3114 : !> \author
3115 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
3116 : type, extends(xoshiro256ss_type) :: xoshiro256ssw_type
3117 : end type
3118 :
3119 : !> \cond excluded
3120 : interface xoshiro256ssw_type
3121 : module procedure :: constructXoshiro256ssw
3122 : end interface
3123 : !> \endcond excluded
3124 :
3125 : !> \brief
3126 : !> Generate, initialize, and return a scalar object of type [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type).
3127 : !>
3128 : !> \details
3129 : !> This generic interface is the constructor of [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type).<br>
3130 : !> Upon return, the output object can be passed to [getUnifRand](@ref pm_distUnif::getUnifRand) and
3131 : !> [setUnifRand](@ref pm_distUnif::setUnifRand) to generate uniformly-distributed
3132 : !> random values of various intrinsic types and kinds.<br>
3133 : !> See the documentation of [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) for example usage and calling interface.
3134 : !>
3135 : !> \param[in] seed : The input scalar of type `integer` of kind \IK64,
3136 : !> containing an integer that serves as the starting point to generate the full deterministic RNG seed.<br>
3137 : !> Specify this input argument if you wish to make random simulations reproducible and deterministic,
3138 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
3139 : !> (**optional**. If missing, it is set to a processor-dependent value based on the current date and time.)
3140 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
3141 : !> This can be,
3142 : !> <ol>
3143 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
3144 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
3145 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
3146 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
3147 : !> </ol>
3148 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
3149 : !> This number will be used to set the RNG seed uniquely on each processor.<br>
3150 : !> (**optional**. If missing, the RNG seed will be set as if it is called in a serial application (or called on the first image).)
3151 : !> \param[in] jump : The input vector of size [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize) of type `integer` of kind \IK64,
3152 : !> whose value sets the jump size of the random number generator.<br>
3153 : !> It can be,
3154 : !> <ol>
3155 : !> <li> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128), corresponding to a jump size of `imageID * 2**128`.<br>
3156 : !> This jump can be used to generate up to `2**128` unique RNG sequences in parallel, each with length `2**128`.<br>
3157 : !> <li> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192), corresponding to a jump size of `imageID * 2**192`.<br>
3158 : !> This jump can be used to generate up to `2**64` unique RNG sequences in parallel, each with length `2**192`.<br>
3159 : !> </ol>
3160 : !> (**optional**. default = [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128))
3161 : !>
3162 : !> \return
3163 : !> `rng` : The output scalar object of type [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)
3164 : !> containing an instance of a [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type) random number generator.<br>
3165 : !>
3166 : !> \interface{constructXoshiro256ssw}
3167 : !> \code{.F90}
3168 : !>
3169 : !> use pm_kind, only: IK
3170 : !> use pm_distUnif, only: xoshiro256ssw_type
3171 : !> use pm_distUnif, only: getUnifRand, setUnifRand
3172 : !> type(xoshiro256ssw_type) :: rng
3173 : !>
3174 : !> rng = xoshiro256ssw_type(seed = seed, imageID = imageID, jump = jump)
3175 : !> rand = getUnifRand(rng, rand, lb, ub)
3176 : !> call setUnifRand(rng, rand, lb, ub)
3177 : !> call setUnifRand(rng, rand)
3178 : !>
3179 : !> \endcode
3180 : !>
3181 : !> \warning
3182 : !> The condition `0 < imageID` must hold for the corresponding input arguments.<br>
3183 : !> \vericon
3184 : !>
3185 : !> \impure
3186 : !>
3187 : !> \see
3188 : !> [isHead](@ref pm_distBern::isHead)<br>
3189 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3190 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3191 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3192 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3193 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3194 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3195 : !> [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw)<br>
3196 : !> [constructFRNG](@ref pm_distUnif::constructFRNG)<br>
3197 : !>
3198 : !> \test
3199 : !> [test_pm_distUnif](@ref test_pm_distUnif)<br>
3200 : !>
3201 : !> \finmain{constructXoshiro256ssw}
3202 : !>
3203 : !> \author
3204 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
3205 : interface constructXoshiro256ssw
3206 : impure module function constructXoshiro256ssw(seed, imageID, jump) result(rng)
3207 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3208 : !DEC$ ATTRIBUTES DLLEXPORT :: constructXoshiro256ssw
3209 : #endif
3210 : use pm_kind, only: IKC => IK64
3211 : integer(IKC) , intent(in), optional :: seed, jump(:)
3212 : integer(IK) , intent(in), optional :: imageID
3213 : type(xoshiro256ssw_type) :: rng
3214 : end function
3215 : end interface
3216 :
3217 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3218 :
3219 : !> \brief
3220 : !> This is the derived type for declaring and generating objects of type [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type)
3221 : !> containing a unique instance of a **greedy** [Xoshiro256**](https://prng.di.unimi.it/) random number generator (RNG).
3222 : !>
3223 : !> \details
3224 : !> Unlike the `Xoshiro256**` algorithm as implemented by the derived type [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type),
3225 : !> the greedy version of the algorithm here does not waste any of the randomly generated 64 bits in each update the RNG state.<br>
3226 : !> See also the documentation of [constructXoshiro256ssg](@ref pm_distUnif::constructXoshiro256ssg) for information on the constructor of this type.<br>
3227 : !>
3228 : !> \param[in] seed : The input scalar of type `integer` of kind \IK64,
3229 : !> containing an integer that serves as the starting point to generate the full deterministic RNG seed.<br>
3230 : !> Specify this input argument if you wish to make random simulations reproducible and deterministic,
3231 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
3232 : !> (**optional**. If missing, it is set to a processor-dependent value based on the current date and time.)
3233 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
3234 : !> This can be,
3235 : !> <ol>
3236 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
3237 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
3238 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
3239 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
3240 : !> </ol>
3241 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
3242 : !> This number will be used to set the RNG seed uniquely on each processor.<br>
3243 : !> (**optional**. If missing, the RNG seed will be set as if it is called in a serial application (or called on the first image).)
3244 : !> \param[in] jump : The input vector of size [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize) of type `integer` of kind \IK64,
3245 : !> whose value sets the jump size of the random number generator.<br>
3246 : !> It can be,
3247 : !> <ol>
3248 : !> <li> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128), corresponding to a jump size of `imageID * 2**128`.<br>
3249 : !> This jump can be used to generate up to `2**128` unique RNG sequences in parallel, each with length `2**128`.<br>
3250 : !> <li> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192), corresponding to a jump size of `imageID * 2**192`.<br>
3251 : !> This jump can be used to generate up to `2**64` unique RNG sequences in parallel, each with length `2**192`.<br>
3252 : !> </ol>
3253 : !> (**optional**. default = [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128))
3254 : !>
3255 : !> \return
3256 : !> `rng` : The output scalar object (or array of objects, of the same rank and shape as the input array-like arguments)
3257 : !> of type [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) containing an instance of a splitmix64
3258 : !> random number generator.<br>
3259 : !>
3260 : !> \interface{xoshiro256ssg_type}
3261 : !> \code{.F90}
3262 : !>
3263 : !> use pm_kind, only: IK
3264 : !> use pm_distUnif, only: xoshiro256ssg_type
3265 : !> type(xoshiro256ssg_type) :: rng
3266 : !>
3267 : !> rng = xoshiro256ssg_type(seed = seed, imageID = imageID, jump = jump)
3268 : !> rand = getUnifRand(rng, rand, lb, ub)
3269 : !> call setUnifRand(rng, rand, lb, ub)
3270 : !> call setUnifRand(rng, rand)
3271 : !>
3272 : !> \endcode
3273 : !>
3274 : !> \warning
3275 : !> The condition `0 < imageID` must hold for the corresponding input arguments.<br>
3276 : !> \vericon
3277 : !>
3278 : !> \warning
3279 : !> Although the components of this derived type are `public`, they are theoretically `protected`.<br>
3280 : !> The end users must not manipulate the component values at any stages of the random number generation.<br>
3281 : !>
3282 : !> \note
3283 : !> Without initializing objects of this derived type, the generated RNGs will always be deterministic,
3284 : !> always yielding identical sequences.<br>
3285 : !>
3286 : !> \see
3287 : !> [rngf](@ref pm_distUnif::rngf)<br>
3288 : !> [isHead](@ref pm_distBern::isHead)<br>
3289 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3290 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3291 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3292 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3293 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3294 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
3295 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
3296 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
3297 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
3298 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3299 : !>
3300 : !> \example{xoshiro256ssg_type}
3301 : !> \include{lineno} example/pm_distUnif/xoshiro256ssg_type/main.F90
3302 : !> \compilef{xoshiro256ssg_type}
3303 : !> \output{xoshiro256ssg_type}
3304 : !> \include{lineno} example/pm_distUnif/xoshiro256ssg_type/main.out.F90
3305 : !> \postproc{xoshiro256ssg_type}
3306 : !> \include{lineno} example/pm_distUnif/xoshiro256ssg_type/main.py
3307 : !> \vis{xoshiro256ssg_type}
3308 : !> \image html pm_distUnif/xoshiro256ssg_type/xoshiro256ssg_type.IK.png width=700
3309 : !> \image html pm_distUnif/xoshiro256ssg_type/xoshiro256ssg_type.CK.png width=700
3310 : !> \image html pm_distUnif/xoshiro256ssg_type/xoshiro256ssg_type.RK.png width=700
3311 : !>
3312 : !> \test
3313 : !> [test_pm_distUnif](@ref test_pm_distUnif)
3314 : !>
3315 : !> \todo
3316 : !> \phigh
3317 : !> An illustration of the distribution of the probability of individual bits being `0` or `1` in the
3318 : !> mantissa of `real`-valued random numbers and `integer` random numbers must be added to the example.<br>
3319 : !>
3320 : !> \finmain{xoshiro256ssg_type}
3321 : !>
3322 : !> \author
3323 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
3324 : type, extends(xoshiro256ss_type) :: xoshiro256ssg_type
3325 : !> \brief
3326 : !> The scalar of type `integer` of default kind \IK, containing the
3327 : !> position of the first unused bit of the `stream` component of the RNG object.
3328 : integer(IK) :: pos = 0_IK
3329 : end type
3330 :
3331 : !> \cond excluded
3332 : interface xoshiro256ssg_type
3333 : module procedure :: constructXoshiro256ssg
3334 : end interface
3335 : !> \endcond excluded
3336 :
3337 : !> \brief
3338 : !> Generate, initialize, and return a scalar object of type [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type).
3339 : !>
3340 : !> \details
3341 : !> This generic interface is the constructor of [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type).<br>
3342 : !> Upon return, the output object can be passed to [getUnifRand](@ref pm_distUnif::getUnifRand) and
3343 : !> [setUnifRand](@ref pm_distUnif::setUnifRand) to generate uniformly-distributed
3344 : !> random values of various intrinsic types and kinds.<br>
3345 : !> See the documentation of [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) for example usage and calling interface.
3346 : !>
3347 : !> \param[in] seed : The input scalar of type `integer` of kind \IK64,
3348 : !> containing an integer that serves as the starting point to generate the full deterministic RNG seed.<br>
3349 : !> Specify this input argument if you wish to make random simulations reproducible and deterministic,
3350 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
3351 : !> (**optional**. If missing, it is set to a processor-dependent value based on the current date and time.)
3352 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
3353 : !> This can be,
3354 : !> <ol>
3355 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
3356 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
3357 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
3358 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
3359 : !> </ol>
3360 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
3361 : !> This number will be used to set the RNG seed uniquely on each processor.<br>
3362 : !> (**optional**. If missing, the RNG seed will be set as if it is called in a serial application (or called on the first image).)
3363 : !> \param[in] jump : The input vector of size [xoshiro256ssStateSize](@ref pm_distUnif::xoshiro256ssStateSize) of type `integer` of kind \IK64,
3364 : !> whose value sets the jump size of the random number generator.<br>
3365 : !> It can be,
3366 : !> <ol>
3367 : !> <li> [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128), corresponding to a jump size of `imageID * 2**128`.<br>
3368 : !> This jump can be used to generate up to `2**128` unique RNG sequences in parallel, each with length `2**128`.<br>
3369 : !> <li> [xoshiro256ssJump192](@ref pm_distUnif::xoshiro256ssJump192), corresponding to a jump size of `imageID * 2**192`.<br>
3370 : !> This jump can be used to generate up to `2**64` unique RNG sequences in parallel, each with length `2**192`.<br>
3371 : !> </ol>
3372 : !> (**optional**. default = [xoshiro256ssJump128](@ref pm_distUnif::xoshiro256ssJump128))
3373 : !>
3374 : !> \return
3375 : !> `rng` : The output scalar object of type [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type)
3376 : !> containing an instance of a [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type) random number generator.<br>
3377 : !>
3378 : !> \interface{constructXoshiro256ssg}
3379 : !> \code{.F90}
3380 : !>
3381 : !> use pm_kind, only: IK
3382 : !> use pm_distUnif, only: xoshiro256ssg_type
3383 : !> type(xoshiro256ssg_type) :: rng
3384 : !>
3385 : !> rng = xoshiro256ssg_type(seed = seed, imageID = imageID, jump = jump)
3386 : !> rand = getUnifRand(rng, rand, lb, ub)
3387 : !> call setUnifRand(rng, rand, lb, ub)
3388 : !> call setUnifRand(rng, rand)
3389 : !>
3390 : !> \endcode
3391 : !>
3392 : !> \warning
3393 : !> The condition `0 < imageID` must hold for the corresponding input arguments.<br>
3394 : !> \vericon
3395 : !>
3396 : !> \impure
3397 : !>
3398 : !> \see
3399 : !> [isHead](@ref pm_distBern::isHead)<br>
3400 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3401 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3402 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3403 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3404 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3405 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3406 : !> [constructXoshiro256ssw](@ref pm_distUnif::constructXoshiro256ssw)<br>
3407 : !> [constructFRNG](@ref pm_distUnif::constructFRNG)<br>
3408 : !>
3409 : !> \test
3410 : !> [test_pm_distUnif](@ref test_pm_distUnif)<br>
3411 : !>
3412 : !> \finmain{constructXoshiro256ssw}
3413 : !>
3414 : !> \author
3415 : !> \FatemehBagheri, Wednesday 12:20 AM, October 13, 2021, Dallas, TX
3416 : interface constructXoshiro256ssg
3417 : impure module function constructXoshiro256ssg(seed, imageID, jump) result(rng)
3418 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3419 : !DEC$ ATTRIBUTES DLLEXPORT :: constructXoshiro256ssg
3420 : #endif
3421 : use pm_kind, only: IKC => IK64
3422 : integer(IKC) , intent(in), optional :: seed, jump(:)
3423 : integer(IK) , intent(in), optional :: imageID
3424 : type(xoshiro256ssg_type) :: rng
3425 : end function
3426 : end interface
3427 :
3428 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3429 :
3430 : !> \brief
3431 : !> This is the derived type for declaring and generating objects of type [splitmix64_type](@ref pm_distUnif::splitmix64_type)
3432 : !> containing a unique instance of an [splitmix64](https://doi.org/10.1145/2660193.2660195) random number generator (RNG).
3433 : !>
3434 : !> \details
3435 : !> See also the documentation of [constructSplitmix64](@ref pm_distUnif::constructSplitmix64) for information on the constructor of this type.<br>
3436 : !>
3437 : !> Splitmix64 is a pseudo-random number generator algorithm that originated from
3438 : !> the Java programming language and is used in many other programming languages.<br>
3439 : !> It is a fairly simple algorithm that is fast but unsuitable for cryptographic purposes and comparable tasks.<br>
3440 : !> The Splitmix64 algorithm is frequently used to calculate random initial states (seed) of other more complex pseudo-random number generators.<br>
3441 : !> The conventional splitmix64 holds one 64bit state (seed) variable and returns 64bits of random binary data upon subsequent calls.<br>
3442 : !> Splitmix64 is comparatively fast; It requires only 9 64-bit arithmetic/logical operations per 64 bits of random binary stream generation.<br>
3443 : !> A conventional linear RNG provides a generate method that returns one pseudorandom value and updates the state of the RNG.<br>
3444 : !> But the splitable RNG also has a second operation, split, that replaces the original RNG with two (seemingly) independent RNG.<br>
3445 : !> This is done by creating and returning a new such RNG and updating the state of the original object.<br>
3446 : !>
3447 : !> <b>Applications</b>
3448 : !>
3449 : !> Splitable RNG make it easy to organize the use of pseudorandom numbers in multithreaded programs structured using forkjoin parallelism.<br>
3450 : !> No locking or synchronization is required (other than the usual memory fence immediately after RNG creation).<br>
3451 : !> Because the generate method has no loops or conditionals, it is also suitable for SIMD or GPU implementation.<br>
3452 : !>
3453 : !> <b>Usage instructions</b>
3454 : !> This derived type contains only the most recently updated state and random bit stream of the RNG.<br>
3455 : !> To generate random values of arbitrary intrinsic kinds (`character`, `integer`, `logical`, `complex`, `real`)
3456 : !> the user must,<br>
3457 : !> <ol>
3458 : !> <li> declare an object of type [splitmix64_type](@ref pm_distUnif::splitmix64_type) and
3459 : !> initialize the object via the type constructor [constructSplitmix64](@ref pm_distUnif::constructSplitmix64)
3460 : !> (see below for the possible calling interfaces),
3461 : !> <li> pass the generated RNG instance to the desired random number generating routines,
3462 : !> <ol>
3463 : !> <li> [getUnifRand](@ref pm_distUnif::getUnifRand),
3464 : !> <li> [setUnifRand](@ref pm_distUnif::setUnifRand),
3465 : !> </ol>
3466 : !> to generate the desired scalar or sequence of random values.<br>
3467 : !> </ol>
3468 : !>
3469 : !> \param[in] seed : The input scalar of type `integer` of kind \IK64,
3470 : !> containing an integer that serves as the starting point to generate the full RNG seed.<br>
3471 : !> Specify this input argument if you wish to make random simulations reproducible and deterministic,
3472 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
3473 : !> (**optional**. If missing, it is set to a processor-dependent value based on the current date and time.)
3474 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
3475 : !> This can be,
3476 : !> <ol>
3477 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
3478 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
3479 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
3480 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
3481 : !> </ol>
3482 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
3483 : !> This number will be used to set the RNG seed uniquely on each processor.<br>
3484 : !> (**optional**. If missing, the RNG seed will be set as if it is called in a serial application (or called on the first image).)
3485 : !>
3486 : !> \return
3487 : !> `rng` : The output scalar object (or array of objects, of the same rank and shape as the input array-like arguments)
3488 : !> of type [splitmix64_type](@ref pm_distUnif::splitmix64_type) containing an instance of a splitmix64
3489 : !> random number generator.<br>
3490 : !>
3491 : !> \interface{splitmix64_type}
3492 : !> \code{.F90}
3493 : !>
3494 : !> use pm_kind, only: IK
3495 : !> use pm_distUnif, only: splitmix64_type
3496 : !> type(splitmix64_type) :: rng
3497 : !>
3498 : !> rng = splitmix64_type(seed = seed, imageID = imageID)
3499 : !> print *, rng%state ! The current RNG state.
3500 : !> print *, rng%stream ! The current 64bit integer random number.
3501 : !> !
3502 : !> \endcode
3503 : !>
3504 : !> \warning
3505 : !> The condition `0 < imageID` must hold for the corresponding input arguments.<br>
3506 : !> \vericon
3507 : !>
3508 : !> \warning
3509 : !> Although the components of this derived type are `public`, they are theoretically `protected`.<br>
3510 : !> The end user must not change the values of the components of an object of type [splitmix64_type](@ref pm_distUnif::splitmix64_type)
3511 : !> at anytime during the random value generation.<br>
3512 : !>
3513 : !> \warning
3514 : !> The Splitmix64 algorithm is not necessarily the best option for generating random values, particularly, for parallel applications.<br>
3515 : !> Use [xoshiro256**](@ref pm_distUnif::xoshiro256ssw_type) algorithm instead.<br>
3516 : !>
3517 : !> \see
3518 : !> [rngf](@ref pm_distUnif::rngf)<br>
3519 : !> [isHead](@ref pm_distBern::isHead)<br>
3520 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3521 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3522 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3523 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3524 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3525 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
3526 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
3527 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
3528 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
3529 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3530 : !>
3531 : !> \example{splitmix64_type}
3532 : !> \include{lineno} example/pm_distUnif/splitmix64_type/main.F90
3533 : !> \compilef{splitmix64_type}
3534 : !> \output{splitmix64_type}
3535 : !> \include{lineno} example/pm_distUnif/splitmix64_type/main.out.F90
3536 : !> \postproc{splitmix64_type}
3537 : !> \include{lineno} example/pm_distUnif/splitmix64_type/main.py
3538 : !> \vis{splitmix64_type}
3539 : !> \image html pm_distUnif/splitmix64_type/splitmix64_type.IK.png width=700
3540 : !> \image html pm_distUnif/splitmix64_type/splitmix64_type.CK.png width=700
3541 : !> \image html pm_distUnif/splitmix64_type/splitmix64_type.RK.png width=700
3542 : !>
3543 : !> \test
3544 : !> [test_pm_distUnif](@ref test_pm_distUnif)<br>
3545 : !>
3546 : !> \todo
3547 : !> \phigh
3548 : !> An illustration of the distribution of the probability of individual bits being `0` or `1` in the
3549 : !> mantissa of `real`-valued random numbers and `integer` random numbers must be added to the example.<br>
3550 : !>
3551 : !> \finmain{splitmix64_type}
3552 : !>
3553 : !> \author
3554 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3555 : type, extends(rngu_type) :: splitmix64_type
3556 : !> \brief
3557 : !> The scalar of type `integer` of kind \IK64, containing the most recently generated random 64-bit stream.
3558 : integer(IK64) :: stream
3559 : !> \brief
3560 : !> The scalar of type `integer` of kind \IK64, containing the most recent RNG state.<br>
3561 : integer(IK64) :: state = 324108011427370141_IK64
3562 : end type
3563 :
3564 : !> \cond excluded
3565 : interface splitmix64_type
3566 : module procedure :: constructSplitmix64
3567 : end interface
3568 : !> \endcond excluded
3569 :
3570 : !> \brief
3571 : !> Generate, initialize, and return a scalar object of type [splitmix64_type](@ref pm_distUnif::splitmix64_type).
3572 : !>
3573 : !> \details
3574 : !> This generic interface is the constructor of [splitmix64_type](@ref pm_distUnif::splitmix64_type).<br>
3575 : !> Upon return, the output object can be passed to [getUnifRand](@ref pm_distUnif::getUnifRand) and
3576 : !> [setUnifRand](@ref pm_distUnif::setUnifRand) to generate uniformly-distributed
3577 : !> random values of various intrinsic types and kinds using the [splitmix64](https://doi.org/10.1145/2660193.2660195) algorithm.<br>
3578 : !> See the documentation of [splitmix64_type](@ref pm_distUnif::splitmix64_type) for example usage and calling interface.
3579 : !>
3580 : !> \param[in] seed : The input scalar of type `integer` of kind \IK64,
3581 : !> containing an integer that serves as the starting point to generate the full RNG seed.<br>
3582 : !> Specify this input argument if you wish to make random simulations reproducible and deterministic,
3583 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
3584 : !> (**optional**. If missing, it is set to a processor-dependent value based on the current date and time.)
3585 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
3586 : !> This can be,
3587 : !> <ol>
3588 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
3589 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
3590 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
3591 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
3592 : !> </ol>
3593 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
3594 : !> This number will be used to set the RNG seed uniquely on each processor.<br>
3595 : !> (**optional**. If missing, the RNG seed will be set as if it is called in a serial application (or called on the first image).)
3596 : !>
3597 : !> \return
3598 : !> `rng` : The output scalar object (or array of objects, of the same rank and shape as the input array-like arguments)
3599 : !> of type [splitmix64_type](@ref pm_distUnif::splitmix64_type) containing an instance of the splitmix64
3600 : !> random number generator.<br>
3601 : !>
3602 : !> \interface{splitmix64_type}
3603 : !> \code{.F90}
3604 : !>
3605 : !> use pm_kind, only: IK
3606 : !> use pm_distUnif, only: splitmix64_type
3607 : !> type(splitmix64_type) :: rng
3608 : !>
3609 : !> rng = splitmix64_type(seed = seed, imageID = imageID)
3610 : !> print *, rng%state ! The current RNG state.
3611 : !> print *, rng%stream ! The current 64bit integer random number.
3612 : !> !
3613 : !> \endcode
3614 : !>
3615 : !> \warning
3616 : !> The condition `0 < imageID` must hold for the corresponding input arguments.<br>
3617 : !> \vericon
3618 : !>
3619 : !> \impure
3620 : !>
3621 : !> \elemental
3622 : !>
3623 : !> \see
3624 : !> [rngf](@ref pm_distUnif::rngf)<br>
3625 : !> [isHead](@ref pm_distBern::isHead)<br>
3626 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3627 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3628 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3629 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3630 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3631 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
3632 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
3633 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
3634 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
3635 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3636 : !>
3637 : !> \test
3638 : !> [test_pm_distUnif](@ref test_pm_distUnif)
3639 : !>
3640 : !> \finmain{constructSplitmix64}
3641 : !>
3642 : !> \author
3643 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3644 : interface constructSplitmix64
3645 : impure elemental module function constructSplitmix64(seed, imageID) result(rng)
3646 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3647 : !DEC$ ATTRIBUTES DLLEXPORT :: constructSplitmix64
3648 : #endif
3649 : use pm_kind, only: IKC => IK64
3650 : integer(IKC) , intent(in), optional :: seed
3651 : integer(IK) , intent(in), optional :: imageID
3652 : type(splitmix64_type) :: rng
3653 : end function
3654 : end interface
3655 :
3656 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3657 :
3658 : !> \cond excluded
3659 : interface setStateNext
3660 :
3661 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3662 :
3663 : pure module subroutine setStateNextSM64(rng)
3664 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3665 : !DEC$ ATTRIBUTES DLLEXPORT :: setStateNextSM64
3666 : #endif
3667 : use pm_kind, only: IK64
3668 : type(splitmix64_type) , intent(inout) :: rng
3669 : end subroutine
3670 :
3671 : pure module subroutine setStateNextX256SSG(rng)
3672 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3673 : !DEC$ ATTRIBUTES DLLEXPORT :: setStateNextX256SSG
3674 : #endif
3675 : use pm_kind, only: IK64
3676 : type(xoshiro256ssg_type), intent(inout) :: rng
3677 : end subroutine
3678 :
3679 : pure module subroutine setStateNextX256SSW(rng)
3680 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3681 : !DEC$ ATTRIBUTES DLLEXPORT :: setStateNextX256SSW
3682 : #endif
3683 : use pm_kind, only: IK64
3684 : type(xoshiro256ssw_type) , intent(inout) :: rng
3685 : end subroutine
3686 :
3687 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3688 :
3689 : end interface
3690 : !> \endcond excluded
3691 :
3692 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3693 :
3694 : !> \cond excluded
3695 : interface setStateJump
3696 :
3697 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3698 :
3699 : ! default jump
3700 : PURE module subroutine setStateJumpX256SSGDJ(rng)
3701 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3702 : !DEC$ ATTRIBUTES DLLEXPORT :: setStateJumpX256SSGDJ
3703 : #endif
3704 : use pm_kind, only: IK64
3705 : type(xoshiro256ssg_type), intent(inout) :: rng
3706 : end subroutine
3707 :
3708 : ! arbitrary jump
3709 : PURE module subroutine setStateJumpX256SSGAJ(rng, jump)
3710 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3711 : !DEC$ ATTRIBUTES DLLEXPORT :: setStateJumpX256SSGAJ
3712 : #endif
3713 : use pm_kind, only: IK64
3714 : type(xoshiro256ssg_type), intent(inout) :: rng
3715 : integer(IK64) , intent(in) :: jump(:)
3716 : end subroutine
3717 :
3718 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3719 :
3720 : ! default jump
3721 : PURE module subroutine setStateJumpX256SSWDJ(rng)
3722 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3723 : !DEC$ ATTRIBUTES DLLEXPORT :: setStateJumpX256SSWDJ
3724 : #endif
3725 : use pm_kind, only: IK64
3726 : type(xoshiro256ssw_type), intent(inout) :: rng
3727 : end subroutine
3728 :
3729 : ! arbitrary jump
3730 : PURE module subroutine setStateJumpX256SSWAJ(rng, jump)
3731 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3732 : !DEC$ ATTRIBUTES DLLEXPORT :: setStateJumpX256SSWAJ
3733 : #endif
3734 : use pm_kind, only: IK64
3735 : type(xoshiro256ssw_type), intent(inout) :: rng
3736 : integer(IK64) , intent(in) :: jump(:)
3737 : end subroutine
3738 :
3739 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3740 :
3741 : end interface
3742 : !> \endcond excluded
3743 :
3744 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3745 :
3746 : !> \brief
3747 : !> Generate and return the size of the seed vector of the Fortran default random number generator (RNG).
3748 : !>
3749 : !> \details
3750 : !> The functionality of this generic interface is equivalent to `random_seed(size = size)`.
3751 : !>
3752 : !> \return
3753 : !> `seedSize` : The output scalar of type `integer` of default kind \IK containing the size of the default Fortran RNG seed vector.
3754 : !>
3755 : !> \interface{getUnifRandStateSize}
3756 : !> \code{.F90}
3757 : !>
3758 : !> use pm_kind, only: IK
3759 : !> use pm_distUnif, only: getUnifRandStateSize
3760 : !> integer(IK) :: seedSize
3761 : !>
3762 : !> seedSize = getUnifRandStateSize()
3763 : !>
3764 : !> \endcode
3765 : !>
3766 : !> \impure
3767 : !>
3768 : !> \see
3769 : !> [rngf](@ref pm_distUnif::rngf)<br>
3770 : !> [isHead](@ref pm_distBern::isHead)<br>
3771 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3772 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3773 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3774 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3775 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3776 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
3777 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
3778 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
3779 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
3780 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3781 : !>
3782 : !> \example{getUnifRandStateSize}
3783 : !> \include{lineno} example/pm_distUnif/getUnifRandStateSize/main.F90
3784 : !> \compilef{getUnifRandStateSize}
3785 : !> \output{getUnifRandStateSize}
3786 : !> \include{lineno} example/pm_distUnif/getUnifRandStateSize/main.out.F90
3787 : !>
3788 : !> \test
3789 : !> [test_pm_distUnif](@ref test_pm_distUnif)
3790 : !>
3791 : !> \finmain{getUnifRandStateSize}
3792 : !>
3793 : !> \author
3794 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3795 : interface getUnifRandStateSize
3796 : impure module function getUnifRandStateSizeDef() result(unifRandStateSize)
3797 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3798 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandStateSizeDef
3799 : #endif
3800 : use pm_kind, only: IK
3801 : integer(IK) :: unifRandStateSize
3802 : end function
3803 : end interface
3804 :
3805 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3806 :
3807 : !> \brief
3808 : !> Generate and return an `allocatable` array of rank `1` containing the state vector of the Fortran default random number generator (RNG) or,
3809 : !> optionally set the RNG state based on a reference input scalar seed, optionally distinctly on each processor.
3810 : !>
3811 : !> \details
3812 : !> The procedures of this generic interface are merely wrappers around the procedures of the generic interface
3813 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState) that additionally return the current RNG state.<br>
3814 : !> If both `seed` and `imageID` input arguments are missing, the procedures simply return the current RNG state.<br>
3815 : !> Otherwise, the behavior is identical to that of [setUnifRandState](@ref pm_distUnif::setUnifRandState).<br>
3816 : !>
3817 : !> \param[in] seed : See the documentation of the corresponding input argument to [setUnifRandState](@ref pm_distUnif::setUnifRandState).<br>
3818 : !> \param[in] imageID : See the documentation of the corresponding input argument to [setUnifRandState](@ref pm_distUnif::setUnifRandState).<br>
3819 : !>
3820 : !> \return
3821 : !> `unifRandState` : The output `allocatable` vector of rank `1` whose length equals the `size` of the random state
3822 : !> vector of the default Fortran RNG as returned by the Fortran intrinsic `random_seed(size = size)`.<br>
3823 : !>
3824 : !> \interface{getUnifRandState}
3825 : !> \code{.F90}
3826 : !>
3827 : !> use pm_lkind, only: IK
3828 : !> use pm_distUnif, only: getUnifRandState
3829 : !> integer(IK), allocatable :: unifRandState(:)
3830 : !>
3831 : !> unifRandState = getUnifRandState(seed = seed, imageID = imageID)
3832 : !>
3833 : !> \endcode
3834 : !>
3835 : !> \impure
3836 : !>
3837 : !> \see
3838 : !> [rngf](@ref pm_distUnif::rngf)<br>
3839 : !> [isHead](@ref pm_distBern::isHead)<br>
3840 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3841 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3842 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3843 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3844 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3845 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
3846 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
3847 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
3848 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
3849 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3850 : !>
3851 : !> \example{getUnifRandState}
3852 : !> \include{lineno} example/pm_distUnif/getUnifRandState/main.F90
3853 : !> \compilef{getUnifRandState}
3854 : !> \output{getUnifRandState}
3855 : !> \include{lineno} example/pm_distUnif/getUnifRandState/main.out.F90
3856 : !>
3857 : !> \test
3858 : !> [test_pm_distUnif](@ref test_pm_distUnif)
3859 : !>
3860 : !> \finmain{getUnifRandState}
3861 : !>
3862 : !> \author
3863 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3864 : interface getUnifRandState
3865 : impure module function getUnifRandStateDef(seed, imageID) result(unifRandState)
3866 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3867 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandStateDef
3868 : #endif
3869 : use pm_kind, only: IK, LK
3870 : integer(IK) , intent(in) , optional :: seed, imageID
3871 : integer(IK) , allocatable :: unifRandState(:)
3872 : end function
3873 : end interface
3874 :
3875 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3876 :
3877 : !> \brief
3878 : !> Set the state of the Fortran default random number generator (RNG) to a random value or to an optionally deterministic,
3879 : !> optionally processor-dependent value based on the user-specified input scalar seed and processor ID.
3880 : !>
3881 : !> \details
3882 : !> The procedures of this generic interface offer a convenient interface for the following tasks:
3883 : !> <ol>
3884 : !> <li> When all optional arguments are missing, this generic interface
3885 : !> (re)sets the state of the default Fortran RNG to random values.<br>
3886 : !> <li> When the optional argument `seed` is present and `imageID` is missing,
3887 : !> this generic interface sets the RNG state vector to a deterministic value
3888 : !> exclusively based on the input scalar `seed`.<br>
3889 : !> The generated state vector is set identically on all
3890 : !> images/processes/threads that individually call this generic interface.<br>
3891 : !> <li> When both optional arguments `seed` and `imageID` are present,
3892 : !> this generic interface sets the RNG state vector to a deterministic value
3893 : !> unique to each process/thread/image (based on the specified input process-unique `imageID`).<br>
3894 : !> </ol>
3895 : !>
3896 : !> \param[in] seed : The input scalar of type `integer` of default kind \IK,
3897 : !> containing a positive integer that serves as the starting point to generate the full RNG state.<br>
3898 : !> Specify this input argument if you wish to make random simulations reproducible,
3899 : !> even between multiple independent runs of the program compiled by the same compiler.<br>
3900 : !> (**optional**. If missing, it is set to a value determined by the current date and time.)
3901 : !> \param[in] imageID : The input positive scalar `integer` of default kind \IK containing the ID of the current image/thread/process.<br>
3902 : !> This can be,
3903 : !> <ol>
3904 : !> <li> The Coarray image ID as returned by Fortran intrinsic `this_image()` within a global team of Coarray images.<br>
3905 : !> <li> The MPI rank of the processor (plus one) as returned by the MPI library intrinsic `mpi_comm_rank()`.<br>
3906 : !> <li> The OpenMP thread number as returned by the OpenMP library intrinsic `omp_get_thread_num()`.<br>
3907 : !> <li> Any (positive) integer that uniquely identifies the current processor from other processes.<br>
3908 : !> </ol>
3909 : !> The image/process/thread ID can be readily obtained by calling [getImageID](@ref pm_parallelism::getImageID).<br>
3910 : !> This number will be used to set the RNG state uniquely on each processor.<br>
3911 : !> (**optional**. If missing, the RNG state will be set identically on all images.)
3912 : !>
3913 : !> \interface{setUnifRandState}
3914 : !> \code{.F90}
3915 : !>
3916 : !> use pm_lkind, only: IK
3917 : !> use pm_distUnif, only: setUnifRandState
3918 : !>
3919 : !> call setUnifRandState(seed = seed, imageID = imageID)
3920 : !>
3921 : !> \endcode
3922 : !>
3923 : !> \warning
3924 : !> The condition `0 < imageID` must hold for the corresponding input arguments.<br>
3925 : !>
3926 : !> \impure
3927 : !>
3928 : !> \see
3929 : !> [rngf](@ref pm_distUnif::rngf)<br>
3930 : !> [isHead](@ref pm_distBern::isHead)<br>
3931 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
3932 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
3933 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
3934 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
3935 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
3936 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
3937 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
3938 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
3939 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
3940 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
3941 : !>
3942 : !> \example{setUnifRandState}
3943 : !> \include{lineno} example/pm_distUnif/setUnifRandState/main.F90
3944 : !> \compilef{setUnifRandState}
3945 : !> \output{setUnifRandState}
3946 : !> \include{lineno} example/pm_distUnif/setUnifRandState/main.out.F90
3947 : !>
3948 : !> \test
3949 : !> [test_pm_distUnif](@ref test_pm_distUnif)
3950 : !>
3951 : !> \finmain{setUnifRandState}
3952 : !>
3953 : !> \author
3954 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3955 : interface setUnifRandState
3956 : impure module subroutine setUnifRandStateDef(seed, imageID)
3957 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3958 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandStateDef
3959 : #endif
3960 : use pm_kind, only: IK
3961 : integer(IK) , intent(in) , optional :: seed, imageID
3962 : end subroutine
3963 : end interface
3964 :
3965 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3966 :
3967 : !> \brief
3968 : !> Generate and return a scalar or a `contiguous` array of rank `1` of length `s1` of randomly uniformly distributed
3969 : !> discrete `logical`, `integer`, `character` value(s), or continuous `real` or `complex value(s) within the specified input range.<br>
3970 : !>
3971 : !> \param[inout] rng : The input/output scalar of type,
3972 : !> <ol>
3973 : !> <li> [rngf_type](@ref pm_distUnif::rngf_type), or
3974 : !> <li> [splitmix64_type](@ref pm_distUnif::splitmix64_type), or
3975 : !> <li> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type),
3976 : !> <li> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type),
3977 : !> </ol>
3978 : !> containing the user-specified random number generator algorithm to be used.<br>
3979 : !> The user must initialize the object with the corresponding type constructors if non-deterministic RNG are desired.
3980 : !> (**optional**, default = [rngf_type](@ref pm_distUnif::rngf_type))
3981 : !> \param[in] lb : The input scalar (or array of the same shape as the desired output `rand` and other input array-like arguments)
3982 : !> of the same type and kind as the output `rand`, representing the lower bound of the Uniform distribution.<br>
3983 : !> If the output random value `rand` is to be of type `logical`, then `lb`, if present, must be `logical(.false., kind = kind(rand))`.<br>
3984 : !> If the input argument `s1` is present, then `lb` must be a scalar.<br>
3985 : !> (**optional**, default = `.false.`)
3986 : !> \param[in] ub : The input scalar or array of the same type, kind, rank, and shape as `lb`, representing the upper bound of the Uniform distribution.<br>
3987 : !> If the input argument `s1` is present, `ub` must be a scalar.<br>
3988 : !> If the output random value `rand` is to be of type `logical`, then `ub`, if present, must be `logical(.true., kind = kind(rand))`.<br>
3989 : !> (**optional**, default = `.true.`)
3990 : !> \param[in] s1 : The input scalar of type `integer` of default kind \IK, representing the size of the output `rand` array along its first dimension.<br>
3991 : !> (**optional**. It must be present if `s2` is present. If missing, the rank and size of the output `rand` is that of `lb` or `ub` with a non-zero rank.)
3992 : !> \param[in] s2 : The input scalar of type `integer` of default kind \IK, representing the size of the output `rand` array along its second dimension.<br>
3993 : !> (**optional**. It must be present if `s3` is present. If missing, the rank and size of the output `rand` is that of `lb` or `ub` with a non-zero rank.)
3994 : !>
3995 : !> \return
3996 : !> `rand` : The output scalar or vector of rank `1` of length `s1` or array of the same shape as the non-zero rank of the input `lb` and `ub`,
3997 : !> containing the uniformly-distributed random output value(s).<br>
3998 : !> If `lb` and `ub` are missing, then the output `rand` is of type `logical` of default kind \LK.<br>
3999 : !> Otherwise, it is either of,
4000 : !> <ol>
4001 : !> <li> type `character` of the same kind as `lb` and `ub`, of the same length type parameter `len` as that of `lb` and `ub` or, <br>
4002 : !> <li> type `integer` of the same kind as `lb` and `ub`, or<br>
4003 : !> <li> type `logical` of the same kind as `lb` and `ub`, or<br>
4004 : !> <li> type `complex` of the same kind as `lb` and `ub`, or<br>
4005 : !> <li> type `real` of the same kind as `lb` and `ub`.<br>
4006 : !> </ol>
4007 : !> Note that,
4008 : !> <ol>
4009 : !> <li> If `lb` is of type `character`, then the random characters will be drawn from the **character collating sequence of the processor**.<br>
4010 : !> <li> If `lb` and `ub` are of type `integer`, then `rand` will be in the interval `[lb, ub]`.<br>
4011 : !> <li> If `lb` and `ub` are of type `real`, then `rand` will be in the interval `[lb, ub)`.<br>
4012 : !> <li> If `lb` and `ub` are of type `character`, then `rand` will be in the interval `[lb, ub]` as defined by the processor collating sequence.<br>
4013 : !> <li> If `lb` and `ub` are of type `complex`, then `rand%%re` and `rand%%im` will be in the intervals `[lb%%re, ub%%re)` and `[lb%%im, ub%%im)` respectively.<br>
4014 : !> <li> If `lb` and `ub` are both missing, then the output will be a `logical` of default kind \LK with possible values `.false._LK` and `.true._LK`.
4015 : !> </ol>
4016 : !>
4017 : !> \interface{getUnifRand}
4018 : !> \code{.F90}
4019 : !>
4020 : !> use pm_distUnif, only: getUnifRand
4021 : !>
4022 : !> rand = getUnifRand() ! Non-elemental, random `logical` output scalar.
4023 : !> rand = getUnifRand(lb, ub) ! Elemental output of the same type and kind as `lb` and `ub`: character, complex, logical, integer, real.
4024 : !> rand(1:s1) = getUnifRand(lb, ub, s1) ! All input arguments must be scalars. Output is a vector of size `s1`, of the same type and kind as `lb` and `ub`.
4025 : !> rand(1:s1,1:s2) = getUnifRand(lb, ub, s1, s2) ! All input arguments must be scalars. Output is a matrix of size `(s1,s2)`, of the same type and kind as `lb` and `ub`.
4026 : !> rand(1:s1,1:s2,1:s3) = getUnifRand(lb, ub, s1, s2, s3) ! All input arguments must be scalars. Output is a cube of size `(s1,s2,s3)`, of the same type and kind as `lb` and `ub`.
4027 : !>
4028 : !> rand = getUnifRand(rng) ! Non-elemental, random `logical` output scalar.
4029 : !> rand = getUnifRand(rng, lb, ub) ! Elemental output of the same type and kind as `lb` and `ub`: character, complex, logical, integer, real.
4030 : !> rand(1:s1) = getUnifRand(rng, lb, ub, s1) ! All input arguments must be scalars. Output is a vector of size `s1`, of the same type and kind as `lb` and `ub`.
4031 : !> rand(1:s1,1:s2) = getUnifRand(rng, lb, ub, s1, s2) ! All input arguments must be scalars. Output is a matrix of size `(s1,s2)`, of the same type and kind as `lb` and `ub`.
4032 : !> rand(1:s1,1:s2,1:s3) = getUnifRand(rng, lb, ub, s1, s2, s3) ! All input arguments must be scalars. Output is a cube of size `(s1,s2,s3)`, of the same type and kind as `lb` and `ub`.
4033 : !> !
4034 : !> \endcode
4035 : !>
4036 : !> \warning
4037 : !> The condition `len(lb) == len(ub) .or. len(lb) == 1 .or. len(ub) == 1` for the corresponding input arguments of type `character`.<br>
4038 : !> The condition `lb <= ub` must hold for the corresponding input arguments where
4039 : !> logical values are compared by the procedures of module [pm_logicalCompare](@ref pm_logicalCompare) and
4040 : !> complex values are compared by the procedures of module [pm_complexCompareAll](@ref pm_complexCompareAll).<br>
4041 : !> \vericons
4042 : !>
4043 : !> \impure
4044 : !>
4045 : !> \elemental
4046 : !> The procedures of this generic interface are non-`elemental` when the argument `rng` is present.<br>
4047 : !>
4048 : !> \remark
4049 : !> The procedures under this generic interface are carefully designed to avoid possible overflow due to
4050 : !> specifying huge negative and positive `lb` and `ub` limits of type `integer`, `complex`, `real`.<br>
4051 : !> This is possible at the cost of making the random number generation slightly more expensive (by a few CPU cycles, equivalent to and extra multiplication).<br>
4052 : !>
4053 : !> \remark
4054 : !> The procedures under the generic interface are all `elemental` when the input arguments `lb` and `ub` are present and `s1` is missing.<br>
4055 : !>
4056 : !> \remark
4057 : !> When the input `s1` argument is present, the procedures under this generic interface will be non-elemental,
4058 : !> and the input arguments `lb` and `ub` must be scalars, because the size of the output `rand` object is determined by `s1`.<br>
4059 : !> Additionally, when there is no input argument, the output will always be a scalar `logical` of default kind \LK.<br>
4060 : !>
4061 : !> \note
4062 : !> The interface `getUnifRand()` corresponds to coin-flipping experiment with two possible outputs: `.true.` (head) and `.false.` (tail).<br>
4063 : !> See [isHead](@ref pm_distBern::isHead) for generating values from a **biased-coin** flipping experiment.<br>
4064 : !>
4065 : !> \note
4066 : !> By default random characters are generated from the ASCII collating sequence to ensure portability across compilers and platforms.<br>
4067 : !> If random uniform characters from the processor collating sequence are desired, specify the `lb` and `ub` inputs
4068 : !> argument as `integer`s of default kind \IK, such that the random numbers are generated from the
4069 : !> processor-dependent character interval `[char(lb), char(ub)]`.<br>
4070 : !>
4071 : !> \see
4072 : !> [rngf](@ref pm_distUnif::rngf)<br>
4073 : !> [isHead](@ref pm_distBern::isHead)<br>
4074 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
4075 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
4076 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
4077 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
4078 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
4079 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
4080 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
4081 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
4082 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
4083 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
4084 : !>
4085 : !> \example{getUnifRand}
4086 : !> \include{lineno} example/pm_distUnif/getUnifRand/main.F90
4087 : !> \compilef{getUnifRand}
4088 : !> \output{getUnifRand}
4089 : !> \include{lineno} example/pm_distUnif/getUnifRand/main.out.F90
4090 : !> \postproc{getUnifRand}
4091 : !> \include{lineno} example/pm_distUnif/getUnifRand/main.py
4092 : !> \vis{getUnifRand}
4093 : !> \image html pm_distUnif/getUnifRand/getUnifRand.CK.png width=700
4094 : !>
4095 : !> \test
4096 : !> [test_pm_distUnif](@ref test_pm_distUnif)
4097 : !>
4098 : !> \todo
4099 : !> The current random `integer` generator uses a simple double precision `real` conversion to `integer` values.<br>
4100 : !> While this works fairly well for most use cases, it may biased for generating large random `integer` of kind \IK4.<br>
4101 : !> A future remedy should use Bitmask with Rejection as described [here](https://www.pcg-random.org/posts/bounded-rands.html).<br>
4102 : !> As of 2021, the use of double precision (64-bit) vs. single-precision for random number generation increases the
4103 : !> computational cost of the algorithms by about three times.<br>
4104 : !>
4105 : !> \finmain{getUnifRand}
4106 : !>
4107 : !> \author
4108 : !> \AmirShahmoradi, Oct 16, 2009, 11:14 AM, Michigan
4109 :
4110 : ! RNGD
4111 :
4112 : interface getUnifRand
4113 :
4114 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4115 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4116 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4117 :
4118 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4119 :
4120 : impure module function getUnifRandRNGDDD_D0_LK() result(rand)
4121 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4122 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDDD_D0_LK
4123 : #endif
4124 : use pm_kind, only: LKC => LK
4125 : logical(LKC) :: rand
4126 : end function
4127 :
4128 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4129 :
4130 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4131 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4132 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4133 :
4134 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4135 :
4136 : #if SK5_ENABLED
4137 : impure elemental module function getUnifRandRNGDLU_D0_SK5(lb, ub) result(rand)
4138 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4139 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_SK5
4140 : #endif
4141 : use pm_kind, only: SKC => SK5
4142 : character(*,SKC) , intent(in) :: lb, ub
4143 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
4144 : end function
4145 : #endif
4146 :
4147 : #if SK4_ENABLED
4148 : impure elemental module function getUnifRandRNGDLU_D0_SK4(lb, ub) result(rand)
4149 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4150 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_SK4
4151 : #endif
4152 : use pm_kind, only: SKC => SK4
4153 : character(*,SKC) , intent(in) :: lb, ub
4154 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
4155 : end function
4156 : #endif
4157 :
4158 : #if SK3_ENABLED
4159 : impure elemental module function getUnifRandRNGDLU_D0_SK3(lb, ub) result(rand)
4160 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4161 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_SK3
4162 : #endif
4163 : use pm_kind, only: SKC => SK3
4164 : character(*,SKC) , intent(in) :: lb, ub
4165 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
4166 : end function
4167 : #endif
4168 :
4169 : #if SK2_ENABLED
4170 : impure elemental module function getUnifRandRNGDLU_D0_SK2(lb, ub) result(rand)
4171 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4172 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_SK2
4173 : #endif
4174 : use pm_kind, only: SKC => SK2
4175 : character(*,SKC) , intent(in) :: lb, ub
4176 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
4177 : end function
4178 : #endif
4179 :
4180 : #if SK1_ENABLED
4181 : impure elemental module function getUnifRandRNGDLU_D0_SK1(lb, ub) result(rand)
4182 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4183 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_SK1
4184 : #endif
4185 : use pm_kind, only: SKC => SK1
4186 : character(*,SKC) , intent(in) :: lb, ub
4187 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
4188 : end function
4189 : #endif
4190 :
4191 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4192 :
4193 : #if IK5_ENABLED
4194 : impure elemental module function getUnifRandRNGDLU_D0_IK5(lb, ub) result(rand)
4195 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4196 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_IK5
4197 : #endif
4198 : use pm_kind, only: IKC => IK5
4199 : integer(IKC) , intent(in) :: lb, ub
4200 : integer(IKC) :: rand
4201 : end function
4202 : #endif
4203 :
4204 : #if IK4_ENABLED
4205 : impure elemental module function getUnifRandRNGDLU_D0_IK4(lb, ub) result(rand)
4206 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4207 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_IK4
4208 : #endif
4209 : use pm_kind, only: IKC => IK4
4210 : integer(IKC) , intent(in) :: lb, ub
4211 : integer(IKC) :: rand
4212 : end function
4213 : #endif
4214 :
4215 : #if IK3_ENABLED
4216 : impure elemental module function getUnifRandRNGDLU_D0_IK3(lb, ub) result(rand)
4217 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4218 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_IK3
4219 : #endif
4220 : use pm_kind, only: IKC => IK3
4221 : integer(IKC) , intent(in) :: lb, ub
4222 : integer(IKC) :: rand
4223 : end function
4224 : #endif
4225 :
4226 : #if IK2_ENABLED
4227 : impure elemental module function getUnifRandRNGDLU_D0_IK2(lb, ub) result(rand)
4228 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4229 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_IK2
4230 : #endif
4231 : use pm_kind, only: IKC => IK2
4232 : integer(IKC) , intent(in) :: lb, ub
4233 : integer(IKC) :: rand
4234 : end function
4235 : #endif
4236 :
4237 : #if IK1_ENABLED
4238 : impure elemental module function getUnifRandRNGDLU_D0_IK1(lb, ub) result(rand)
4239 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4240 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_IK1
4241 : #endif
4242 : use pm_kind, only: IKC => IK1
4243 : integer(IKC) , intent(in) :: lb, ub
4244 : integer(IKC) :: rand
4245 : end function
4246 : #endif
4247 :
4248 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4249 :
4250 : #if LK5_ENABLED
4251 : impure elemental module function getUnifRandRNGDLU_D0_LK5(lb, ub) result(rand)
4252 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4253 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_LK5
4254 : #endif
4255 : use pm_kind, only: LKC => LK5
4256 : logical(LKC) , intent(in) :: lb, ub
4257 : logical(LKC) :: rand
4258 : end function
4259 : #endif
4260 :
4261 : #if LK4_ENABLED
4262 : impure elemental module function getUnifRandRNGDLU_D0_LK4(lb, ub) result(rand)
4263 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4264 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_LK4
4265 : #endif
4266 : use pm_kind, only: LKC => LK4
4267 : logical(LKC) , intent(in) :: lb, ub
4268 : logical(LKC) :: rand
4269 : end function
4270 : #endif
4271 :
4272 : #if LK3_ENABLED
4273 : impure elemental module function getUnifRandRNGDLU_D0_LK3(lb, ub) result(rand)
4274 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4275 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_LK3
4276 : #endif
4277 : use pm_kind, only: LKC => LK3
4278 : logical(LKC) , intent(in) :: lb, ub
4279 : logical(LKC) :: rand
4280 : end function
4281 : #endif
4282 :
4283 : #if LK2_ENABLED
4284 : impure elemental module function getUnifRandRNGDLU_D0_LK2(lb, ub) result(rand)
4285 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4286 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_LK2
4287 : #endif
4288 : use pm_kind, only: LKC => LK2
4289 : logical(LKC) , intent(in) :: lb, ub
4290 : logical(LKC) :: rand
4291 : end function
4292 : #endif
4293 :
4294 : #if LK1_ENABLED
4295 : impure elemental module function getUnifRandRNGDLU_D0_LK1(lb, ub) result(rand)
4296 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4297 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_LK1
4298 : #endif
4299 : use pm_kind, only: LKC => LK1
4300 : logical(LKC) , intent(in) :: lb, ub
4301 : logical(LKC) :: rand
4302 : end function
4303 : #endif
4304 :
4305 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4306 :
4307 : #if CK5_ENABLED
4308 : impure elemental module function getUnifRandRNGDLU_D0_CK5(lb, ub) result(rand)
4309 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4310 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_CK5
4311 : #endif
4312 : use pm_kind, only: CKC => CK5
4313 : complex(CKC) , intent(in) :: lb, ub
4314 : complex(CKC) :: rand
4315 : end function
4316 : #endif
4317 :
4318 : #if CK4_ENABLED
4319 : impure elemental module function getUnifRandRNGDLU_D0_CK4(lb, ub) result(rand)
4320 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4321 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_CK4
4322 : #endif
4323 : use pm_kind, only: CKC => CK4
4324 : complex(CKC) , intent(in) :: lb, ub
4325 : complex(CKC) :: rand
4326 : end function
4327 : #endif
4328 :
4329 : #if CK3_ENABLED
4330 : impure elemental module function getUnifRandRNGDLU_D0_CK3(lb, ub) result(rand)
4331 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4332 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_CK3
4333 : #endif
4334 : use pm_kind, only: CKC => CK3
4335 : complex(CKC) , intent(in) :: lb, ub
4336 : complex(CKC) :: rand
4337 : end function
4338 : #endif
4339 :
4340 : #if CK2_ENABLED
4341 : impure elemental module function getUnifRandRNGDLU_D0_CK2(lb, ub) result(rand)
4342 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4343 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_CK2
4344 : #endif
4345 : use pm_kind, only: CKC => CK2
4346 : complex(CKC) , intent(in) :: lb, ub
4347 : complex(CKC) :: rand
4348 : end function
4349 : #endif
4350 :
4351 : #if CK1_ENABLED
4352 : impure elemental module function getUnifRandRNGDLU_D0_CK1(lb, ub) result(rand)
4353 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4354 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_CK1
4355 : #endif
4356 : use pm_kind, only: CKC => CK1
4357 : complex(CKC) , intent(in) :: lb, ub
4358 : complex(CKC) :: rand
4359 : end function
4360 : #endif
4361 :
4362 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4363 :
4364 : #if RK5_ENABLED
4365 : impure elemental module function getUnifRandRNGDLU_D0_RK5(lb, ub) result(rand)
4366 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4367 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_RK5
4368 : #endif
4369 : use pm_kind, only: RKC => RK5
4370 : real(RKC) , intent(in) :: lb, ub
4371 : real(RKC) :: rand
4372 : end function
4373 : #endif
4374 :
4375 : #if RK4_ENABLED
4376 : impure elemental module function getUnifRandRNGDLU_D0_RK4(lb, ub) result(rand)
4377 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4378 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_RK4
4379 : #endif
4380 : use pm_kind, only: RKC => RK4
4381 : real(RKC) , intent(in) :: lb, ub
4382 : real(RKC) :: rand
4383 : end function
4384 : #endif
4385 :
4386 : #if RK3_ENABLED
4387 : impure elemental module function getUnifRandRNGDLU_D0_RK3(lb, ub) result(rand)
4388 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4389 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_RK3
4390 : #endif
4391 : use pm_kind, only: RKC => RK3
4392 : real(RKC) , intent(in) :: lb, ub
4393 : real(RKC) :: rand
4394 : end function
4395 : #endif
4396 :
4397 : #if RK2_ENABLED
4398 : impure elemental module function getUnifRandRNGDLU_D0_RK2(lb, ub) result(rand)
4399 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4400 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_RK2
4401 : #endif
4402 : use pm_kind, only: RKC => RK2
4403 : real(RKC) , intent(in) :: lb, ub
4404 : real(RKC) :: rand
4405 : end function
4406 : #endif
4407 :
4408 : #if RK1_ENABLED
4409 : impure elemental module function getUnifRandRNGDLU_D0_RK1(lb, ub) result(rand)
4410 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4411 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D0_RK1
4412 : #endif
4413 : use pm_kind, only: RKC => RK1
4414 : real(RKC) , intent(in) :: lb, ub
4415 : real(RKC) :: rand
4416 : end function
4417 : #endif
4418 :
4419 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4420 :
4421 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4422 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4423 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4424 :
4425 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4426 :
4427 : #if SK5_ENABLED
4428 : impure module function getUnifRandRNGDLU_D1_SK5(lb, ub, s1) result(rand)
4429 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4430 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_SK5
4431 : #endif
4432 : use pm_kind, only: SKC => SK5
4433 : character(*,SKC) , intent(in) :: lb, ub
4434 : integer(IK) , intent(in) :: s1
4435 : character(len(lb,IK),SKC) :: rand(s1)
4436 : end function
4437 : #endif
4438 :
4439 : #if SK4_ENABLED
4440 : impure module function getUnifRandRNGDLU_D1_SK4(lb, ub, s1) result(rand)
4441 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4442 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_SK4
4443 : #endif
4444 : use pm_kind, only: SKC => SK4
4445 : character(*,SKC) , intent(in) :: lb, ub
4446 : integer(IK) , intent(in) :: s1
4447 : character(len(lb,IK),SKC) :: rand(s1)
4448 : end function
4449 : #endif
4450 :
4451 : #if SK3_ENABLED
4452 : impure module function getUnifRandRNGDLU_D1_SK3(lb, ub, s1) result(rand)
4453 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4454 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_SK3
4455 : #endif
4456 : use pm_kind, only: SKC => SK3
4457 : character(*,SKC) , intent(in) :: lb, ub
4458 : integer(IK) , intent(in) :: s1
4459 : character(len(lb,IK),SKC) :: rand(s1)
4460 : end function
4461 : #endif
4462 :
4463 : #if SK2_ENABLED
4464 : impure module function getUnifRandRNGDLU_D1_SK2(lb, ub, s1) result(rand)
4465 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4466 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_SK2
4467 : #endif
4468 : use pm_kind, only: SKC => SK2
4469 : character(*,SKC) , intent(in) :: lb, ub
4470 : integer(IK) , intent(in) :: s1
4471 : character(len(lb,IK),SKC) :: rand(s1)
4472 : end function
4473 : #endif
4474 :
4475 : #if SK1_ENABLED
4476 : impure module function getUnifRandRNGDLU_D1_SK1(lb, ub, s1) result(rand)
4477 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4478 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_SK1
4479 : #endif
4480 : use pm_kind, only: SKC => SK1
4481 : character(*,SKC) , intent(in) :: lb, ub
4482 : integer(IK) , intent(in) :: s1
4483 : character(len(lb,IK),SKC) :: rand(s1)
4484 : end function
4485 : #endif
4486 :
4487 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4488 :
4489 : #if IK5_ENABLED
4490 : impure module function getUnifRandRNGDLU_D1_IK5(lb, ub, s1) result(rand)
4491 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4492 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_IK5
4493 : #endif
4494 : use pm_kind, only: IKC => IK5
4495 : integer(IKC) , intent(in) :: lb, ub
4496 : integer(IK) , intent(in) :: s1
4497 : integer(IKC) :: rand(s1)
4498 : end function
4499 : #endif
4500 :
4501 : #if IK4_ENABLED
4502 : impure module function getUnifRandRNGDLU_D1_IK4(lb, ub, s1) result(rand)
4503 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4504 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_IK4
4505 : #endif
4506 : use pm_kind, only: IKC => IK4
4507 : integer(IKC) , intent(in) :: lb, ub
4508 : integer(IK) , intent(in) :: s1
4509 : integer(IKC) :: rand(s1)
4510 : end function
4511 : #endif
4512 :
4513 : #if IK3_ENABLED
4514 : impure module function getUnifRandRNGDLU_D1_IK3(lb, ub, s1) result(rand)
4515 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4516 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_IK3
4517 : #endif
4518 : use pm_kind, only: IKC => IK3
4519 : integer(IKC) , intent(in) :: lb, ub
4520 : integer(IK) , intent(in) :: s1
4521 : integer(IKC) :: rand(s1)
4522 : end function
4523 : #endif
4524 :
4525 : #if IK2_ENABLED
4526 : impure module function getUnifRandRNGDLU_D1_IK2(lb, ub, s1) result(rand)
4527 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4528 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_IK2
4529 : #endif
4530 : use pm_kind, only: IKC => IK2
4531 : integer(IKC) , intent(in) :: lb, ub
4532 : integer(IK) , intent(in) :: s1
4533 : integer(IKC) :: rand(s1)
4534 : end function
4535 : #endif
4536 :
4537 : #if IK1_ENABLED
4538 : impure module function getUnifRandRNGDLU_D1_IK1(lb, ub, s1) result(rand)
4539 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4540 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_IK1
4541 : #endif
4542 : use pm_kind, only: IKC => IK1
4543 : integer(IKC) , intent(in) :: lb, ub
4544 : integer(IK) , intent(in) :: s1
4545 : integer(IKC) :: rand(s1)
4546 : end function
4547 : #endif
4548 :
4549 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4550 :
4551 : #if LK5_ENABLED
4552 : impure module function getUnifRandRNGDLU_D1_LK5(lb, ub, s1) result(rand)
4553 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4554 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_LK5
4555 : #endif
4556 : use pm_kind, only: LKC => LK5
4557 : logical(LKC) , intent(in) :: lb, ub
4558 : integer(IK) , intent(in) :: s1
4559 : logical(LKC) :: rand(s1)
4560 : end function
4561 : #endif
4562 :
4563 : #if LK4_ENABLED
4564 : impure module function getUnifRandRNGDLU_D1_LK4(lb, ub, s1) result(rand)
4565 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4566 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_LK4
4567 : #endif
4568 : use pm_kind, only: LKC => LK4
4569 : logical(LKC) , intent(in) :: lb, ub
4570 : integer(IK) , intent(in) :: s1
4571 : logical(LKC) :: rand(s1)
4572 : end function
4573 : #endif
4574 :
4575 : #if LK3_ENABLED
4576 : impure module function getUnifRandRNGDLU_D1_LK3(lb, ub, s1) result(rand)
4577 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4578 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_LK3
4579 : #endif
4580 : use pm_kind, only: LKC => LK3
4581 : logical(LKC) , intent(in) :: lb, ub
4582 : integer(IK) , intent(in) :: s1
4583 : logical(LKC) :: rand(s1)
4584 : end function
4585 : #endif
4586 :
4587 : #if LK2_ENABLED
4588 : impure module function getUnifRandRNGDLU_D1_LK2(lb, ub, s1) result(rand)
4589 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4590 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_LK2
4591 : #endif
4592 : use pm_kind, only: LKC => LK2
4593 : logical(LKC) , intent(in) :: lb, ub
4594 : integer(IK) , intent(in) :: s1
4595 : logical(LKC) :: rand(s1)
4596 : end function
4597 : #endif
4598 :
4599 : #if LK1_ENABLED
4600 : impure module function getUnifRandRNGDLU_D1_LK1(lb, ub, s1) result(rand)
4601 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4602 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_LK1
4603 : #endif
4604 : use pm_kind, only: LKC => LK1
4605 : logical(LKC) , intent(in) :: lb, ub
4606 : integer(IK) , intent(in) :: s1
4607 : logical(LKC) :: rand(s1)
4608 : end function
4609 : #endif
4610 :
4611 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4612 :
4613 : #if CK5_ENABLED
4614 : impure module function getUnifRandRNGDLU_D1_CK5(lb, ub, s1) result(rand)
4615 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4616 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_CK5
4617 : #endif
4618 : use pm_kind, only: CKC => CK5
4619 : complex(CKC) , intent(in) :: lb, ub
4620 : integer(IK) , intent(in) :: s1
4621 : complex(CKC) :: rand(s1)
4622 : end function
4623 : #endif
4624 :
4625 : #if CK4_ENABLED
4626 : impure module function getUnifRandRNGDLU_D1_CK4(lb, ub, s1) result(rand)
4627 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4628 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_CK4
4629 : #endif
4630 : use pm_kind, only: CKC => CK4
4631 : complex(CKC) , intent(in) :: lb, ub
4632 : integer(IK) , intent(in) :: s1
4633 : complex(CKC) :: rand(s1)
4634 : end function
4635 : #endif
4636 :
4637 : #if CK3_ENABLED
4638 : impure module function getUnifRandRNGDLU_D1_CK3(lb, ub, s1) result(rand)
4639 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4640 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_CK3
4641 : #endif
4642 : use pm_kind, only: CKC => CK3
4643 : complex(CKC) , intent(in) :: lb, ub
4644 : integer(IK) , intent(in) :: s1
4645 : complex(CKC) :: rand(s1)
4646 : end function
4647 : #endif
4648 :
4649 : #if CK2_ENABLED
4650 : impure module function getUnifRandRNGDLU_D1_CK2(lb, ub, s1) result(rand)
4651 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4652 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_CK2
4653 : #endif
4654 : use pm_kind, only: CKC => CK2
4655 : complex(CKC) , intent(in) :: lb, ub
4656 : integer(IK) , intent(in) :: s1
4657 : complex(CKC) :: rand(s1)
4658 : end function
4659 : #endif
4660 :
4661 : #if CK1_ENABLED
4662 : impure module function getUnifRandRNGDLU_D1_CK1(lb, ub, s1) result(rand)
4663 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4664 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_CK1
4665 : #endif
4666 : use pm_kind, only: CKC => CK1
4667 : complex(CKC) , intent(in) :: lb, ub
4668 : integer(IK) , intent(in) :: s1
4669 : complex(CKC) :: rand(s1)
4670 : end function
4671 : #endif
4672 :
4673 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4674 :
4675 : #if RK5_ENABLED
4676 : impure module function getUnifRandRNGDLU_D1_RK5(lb, ub, s1) result(rand)
4677 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4678 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_RK5
4679 : #endif
4680 : use pm_kind, only: RKC => RK5
4681 : real(RKC) , intent(in) :: lb, ub
4682 : integer(IK) , intent(in) :: s1
4683 : real(RKC) :: rand(s1)
4684 : end function
4685 :
4686 : #endif
4687 :
4688 : #if RK4_ENABLED
4689 : impure module function getUnifRandRNGDLU_D1_RK4(lb, ub, s1) result(rand)
4690 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4691 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_RK4
4692 : #endif
4693 : use pm_kind, only: RKC => RK4
4694 : real(RKC) , intent(in) :: lb, ub
4695 : integer(IK) , intent(in) :: s1
4696 : real(RKC) :: rand(s1)
4697 : end function
4698 :
4699 : #endif
4700 :
4701 : #if RK3_ENABLED
4702 : impure module function getUnifRandRNGDLU_D1_RK3(lb, ub, s1) result(rand)
4703 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4704 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_RK3
4705 : #endif
4706 : use pm_kind, only: RKC => RK3
4707 : real(RKC) , intent(in) :: lb, ub
4708 : integer(IK) , intent(in) :: s1
4709 : real(RKC) :: rand(s1)
4710 : end function
4711 :
4712 : #endif
4713 :
4714 : #if RK2_ENABLED
4715 : impure module function getUnifRandRNGDLU_D1_RK2(lb, ub, s1) result(rand)
4716 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4717 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_RK2
4718 : #endif
4719 : use pm_kind, only: RKC => RK2
4720 : real(RKC) , intent(in) :: lb, ub
4721 : integer(IK) , intent(in) :: s1
4722 : real(RKC) :: rand(s1)
4723 : end function
4724 : #endif
4725 :
4726 : #if RK1_ENABLED
4727 : impure module function getUnifRandRNGDLU_D1_RK1(lb, ub, s1) result(rand)
4728 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4729 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D1_RK1
4730 : #endif
4731 : use pm_kind, only: RKC => RK1
4732 : real(RKC) , intent(in) :: lb, ub
4733 : integer(IK) , intent(in) :: s1
4734 : real(RKC) :: rand(s1)
4735 : end function
4736 : #endif
4737 :
4738 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4739 :
4740 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4741 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4742 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4743 :
4744 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4745 :
4746 : #if SK5_ENABLED
4747 : impure module function getUnifRandRNGDLU_D2_SK5(lb, ub, s1, s2) result(rand)
4748 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4749 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_SK5
4750 : #endif
4751 : use pm_kind, only: SKC => SK5
4752 : character(*,SKC) , intent(in) :: lb, ub
4753 : integer(IK) , intent(in) :: s1, s2
4754 : character(len(lb,IK),SKC) :: rand(s1, s2)
4755 : end function
4756 : #endif
4757 :
4758 : #if SK4_ENABLED
4759 : impure module function getUnifRandRNGDLU_D2_SK4(lb, ub, s1, s2) result(rand)
4760 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4761 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_SK4
4762 : #endif
4763 : use pm_kind, only: SKC => SK4
4764 : character(*,SKC) , intent(in) :: lb, ub
4765 : integer(IK) , intent(in) :: s1, s2
4766 : character(len(lb,IK),SKC) :: rand(s1, s2)
4767 : end function
4768 : #endif
4769 :
4770 : #if SK3_ENABLED
4771 : impure module function getUnifRandRNGDLU_D2_SK3(lb, ub, s1, s2) result(rand)
4772 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4773 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_SK3
4774 : #endif
4775 : use pm_kind, only: SKC => SK3
4776 : character(*,SKC) , intent(in) :: lb, ub
4777 : integer(IK) , intent(in) :: s1, s2
4778 : character(len(lb,IK),SKC) :: rand(s1, s2)
4779 : end function
4780 : #endif
4781 :
4782 : #if SK2_ENABLED
4783 : impure module function getUnifRandRNGDLU_D2_SK2(lb, ub, s1, s2) result(rand)
4784 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4785 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_SK2
4786 : #endif
4787 : use pm_kind, only: SKC => SK2
4788 : character(*,SKC) , intent(in) :: lb, ub
4789 : integer(IK) , intent(in) :: s1, s2
4790 : character(len(lb,IK),SKC) :: rand(s1, s2)
4791 : end function
4792 : #endif
4793 :
4794 : #if SK1_ENABLED
4795 : impure module function getUnifRandRNGDLU_D2_SK1(lb, ub, s1, s2) result(rand)
4796 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4797 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_SK1
4798 : #endif
4799 : use pm_kind, only: SKC => SK1
4800 : character(*,SKC) , intent(in) :: lb, ub
4801 : integer(IK) , intent(in) :: s1, s2
4802 : character(len(lb,IK),SKC) :: rand(s1, s2)
4803 : end function
4804 : #endif
4805 :
4806 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4807 :
4808 : #if IK5_ENABLED
4809 : impure module function getUnifRandRNGDLU_D2_IK5(lb, ub, s1, s2) result(rand)
4810 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4811 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_IK5
4812 : #endif
4813 : use pm_kind, only: IKC => IK5
4814 : integer(IKC) , intent(in) :: lb, ub
4815 : integer(IK) , intent(in) :: s1, s2
4816 : integer(IKC) :: rand(s1, s2)
4817 : end function
4818 : #endif
4819 :
4820 : #if IK4_ENABLED
4821 : impure module function getUnifRandRNGDLU_D2_IK4(lb, ub, s1, s2) result(rand)
4822 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4823 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_IK4
4824 : #endif
4825 : use pm_kind, only: IKC => IK4
4826 : integer(IKC) , intent(in) :: lb, ub
4827 : integer(IK) , intent(in) :: s1, s2
4828 : integer(IKC) :: rand(s1, s2)
4829 : end function
4830 : #endif
4831 :
4832 : #if IK3_ENABLED
4833 : impure module function getUnifRandRNGDLU_D2_IK3(lb, ub, s1, s2) result(rand)
4834 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4835 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_IK3
4836 : #endif
4837 : use pm_kind, only: IKC => IK3
4838 : integer(IKC) , intent(in) :: lb, ub
4839 : integer(IK) , intent(in) :: s1, s2
4840 : integer(IKC) :: rand(s1, s2)
4841 : end function
4842 : #endif
4843 :
4844 : #if IK2_ENABLED
4845 : impure module function getUnifRandRNGDLU_D2_IK2(lb, ub, s1, s2) result(rand)
4846 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4847 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_IK2
4848 : #endif
4849 : use pm_kind, only: IKC => IK2
4850 : integer(IKC) , intent(in) :: lb, ub
4851 : integer(IK) , intent(in) :: s1, s2
4852 : integer(IKC) :: rand(s1, s2)
4853 : end function
4854 : #endif
4855 :
4856 : #if IK1_ENABLED
4857 : impure module function getUnifRandRNGDLU_D2_IK1(lb, ub, s1, s2) result(rand)
4858 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4859 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_IK1
4860 : #endif
4861 : use pm_kind, only: IKC => IK1
4862 : integer(IKC) , intent(in) :: lb, ub
4863 : integer(IK) , intent(in) :: s1, s2
4864 : integer(IKC) :: rand(s1, s2)
4865 : end function
4866 : #endif
4867 :
4868 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4869 :
4870 : #if LK5_ENABLED
4871 : impure module function getUnifRandRNGDLU_D2_LK5(lb, ub, s1, s2) result(rand)
4872 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4873 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_LK5
4874 : #endif
4875 : use pm_kind, only: LKC => LK5
4876 : logical(LKC) , intent(in) :: lb, ub
4877 : integer(IK) , intent(in) :: s1, s2
4878 : logical(LKC) :: rand(s1, s2)
4879 : end function
4880 : #endif
4881 :
4882 : #if LK4_ENABLED
4883 : impure module function getUnifRandRNGDLU_D2_LK4(lb, ub, s1, s2) result(rand)
4884 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4885 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_LK4
4886 : #endif
4887 : use pm_kind, only: LKC => LK4
4888 : logical(LKC) , intent(in) :: lb, ub
4889 : integer(IK) , intent(in) :: s1, s2
4890 : logical(LKC) :: rand(s1, s2)
4891 : end function
4892 : #endif
4893 :
4894 : #if LK3_ENABLED
4895 : impure module function getUnifRandRNGDLU_D2_LK3(lb, ub, s1, s2) result(rand)
4896 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4897 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_LK3
4898 : #endif
4899 : use pm_kind, only: LKC => LK3
4900 : logical(LKC) , intent(in) :: lb, ub
4901 : integer(IK) , intent(in) :: s1, s2
4902 : logical(LKC) :: rand(s1, s2)
4903 : end function
4904 : #endif
4905 :
4906 : #if LK2_ENABLED
4907 : impure module function getUnifRandRNGDLU_D2_LK2(lb, ub, s1, s2) result(rand)
4908 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4909 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_LK2
4910 : #endif
4911 : use pm_kind, only: LKC => LK2
4912 : logical(LKC) , intent(in) :: lb, ub
4913 : integer(IK) , intent(in) :: s1, s2
4914 : logical(LKC) :: rand(s1, s2)
4915 : end function
4916 : #endif
4917 :
4918 : #if LK1_ENABLED
4919 : impure module function getUnifRandRNGDLU_D2_LK1(lb, ub, s1, s2) result(rand)
4920 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4921 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_LK1
4922 : #endif
4923 : use pm_kind, only: LKC => LK1
4924 : logical(LKC) , intent(in) :: lb, ub
4925 : integer(IK) , intent(in) :: s1, s2
4926 : logical(LKC) :: rand(s1, s2)
4927 : end function
4928 : #endif
4929 :
4930 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4931 :
4932 : #if CK5_ENABLED
4933 : impure module function getUnifRandRNGDLU_D2_CK5(lb, ub, s1, s2) result(rand)
4934 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4935 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_CK5
4936 : #endif
4937 : use pm_kind, only: CKC => CK5
4938 : complex(CKC) , intent(in) :: lb, ub
4939 : integer(IK) , intent(in) :: s1, s2
4940 : complex(CKC) :: rand(s1, s2)
4941 : end function
4942 : #endif
4943 :
4944 : #if CK4_ENABLED
4945 : impure module function getUnifRandRNGDLU_D2_CK4(lb, ub, s1, s2) result(rand)
4946 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4947 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_CK4
4948 : #endif
4949 : use pm_kind, only: CKC => CK4
4950 : complex(CKC) , intent(in) :: lb, ub
4951 : integer(IK) , intent(in) :: s1, s2
4952 : complex(CKC) :: rand(s1, s2)
4953 : end function
4954 : #endif
4955 :
4956 : #if CK3_ENABLED
4957 : impure module function getUnifRandRNGDLU_D2_CK3(lb, ub, s1, s2) result(rand)
4958 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4959 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_CK3
4960 : #endif
4961 : use pm_kind, only: CKC => CK3
4962 : complex(CKC) , intent(in) :: lb, ub
4963 : integer(IK) , intent(in) :: s1, s2
4964 : complex(CKC) :: rand(s1, s2)
4965 : end function
4966 : #endif
4967 :
4968 : #if CK2_ENABLED
4969 : impure module function getUnifRandRNGDLU_D2_CK2(lb, ub, s1, s2) result(rand)
4970 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4971 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_CK2
4972 : #endif
4973 : use pm_kind, only: CKC => CK2
4974 : complex(CKC) , intent(in) :: lb, ub
4975 : integer(IK) , intent(in) :: s1, s2
4976 : complex(CKC) :: rand(s1, s2)
4977 : end function
4978 : #endif
4979 :
4980 : #if CK1_ENABLED
4981 : impure module function getUnifRandRNGDLU_D2_CK1(lb, ub, s1, s2) result(rand)
4982 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4983 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_CK1
4984 : #endif
4985 : use pm_kind, only: CKC => CK1
4986 : complex(CKC) , intent(in) :: lb, ub
4987 : integer(IK) , intent(in) :: s1, s2
4988 : complex(CKC) :: rand(s1, s2)
4989 : end function
4990 : #endif
4991 :
4992 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4993 :
4994 : #if RK5_ENABLED
4995 : impure module function getUnifRandRNGDLU_D2_RK5(lb, ub, s1, s2) result(rand)
4996 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4997 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_RK5
4998 : #endif
4999 : use pm_kind, only: RKC => RK5
5000 : real(RKC) , intent(in) :: lb, ub
5001 : integer(IK) , intent(in) :: s1, s2
5002 : real(RKC) :: rand(s1, s2)
5003 : end function
5004 :
5005 : #endif
5006 :
5007 : #if RK4_ENABLED
5008 : impure module function getUnifRandRNGDLU_D2_RK4(lb, ub, s1, s2) result(rand)
5009 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5010 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_RK4
5011 : #endif
5012 : use pm_kind, only: RKC => RK4
5013 : real(RKC) , intent(in) :: lb, ub
5014 : integer(IK) , intent(in) :: s1, s2
5015 : real(RKC) :: rand(s1, s2)
5016 : end function
5017 :
5018 : #endif
5019 :
5020 : #if RK3_ENABLED
5021 : impure module function getUnifRandRNGDLU_D2_RK3(lb, ub, s1, s2) result(rand)
5022 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5023 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_RK3
5024 : #endif
5025 : use pm_kind, only: RKC => RK3
5026 : real(RKC) , intent(in) :: lb, ub
5027 : integer(IK) , intent(in) :: s1, s2
5028 : real(RKC) :: rand(s1, s2)
5029 : end function
5030 :
5031 : #endif
5032 :
5033 : #if RK2_ENABLED
5034 : impure module function getUnifRandRNGDLU_D2_RK2(lb, ub, s1, s2) result(rand)
5035 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5036 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_RK2
5037 : #endif
5038 : use pm_kind, only: RKC => RK2
5039 : real(RKC) , intent(in) :: lb, ub
5040 : integer(IK) , intent(in) :: s1, s2
5041 : real(RKC) :: rand(s1, s2)
5042 : end function
5043 : #endif
5044 :
5045 : #if RK1_ENABLED
5046 : impure module function getUnifRandRNGDLU_D2_RK1(lb, ub, s1, s2) result(rand)
5047 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5048 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D2_RK1
5049 : #endif
5050 : use pm_kind, only: RKC => RK1
5051 : real(RKC) , intent(in) :: lb, ub
5052 : integer(IK) , intent(in) :: s1, s2
5053 : real(RKC) :: rand(s1, s2)
5054 : end function
5055 : #endif
5056 :
5057 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5058 :
5059 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5060 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5061 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5062 :
5063 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5064 :
5065 : #if SK5_ENABLED
5066 : impure module function getUnifRandRNGDLU_D3_SK5(lb, ub, s1, s2, s3) result(rand)
5067 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5068 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_SK5
5069 : #endif
5070 : use pm_kind, only: SKC => SK5
5071 : character(*,SKC) , intent(in) :: lb, ub
5072 : integer(IK) , intent(in) :: s1, s2, s3
5073 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
5074 : end function
5075 : #endif
5076 :
5077 : #if SK4_ENABLED
5078 : impure module function getUnifRandRNGDLU_D3_SK4(lb, ub, s1, s2, s3) result(rand)
5079 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5080 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_SK4
5081 : #endif
5082 : use pm_kind, only: SKC => SK4
5083 : character(*,SKC) , intent(in) :: lb, ub
5084 : integer(IK) , intent(in) :: s1, s2, s3
5085 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
5086 : end function
5087 : #endif
5088 :
5089 : #if SK3_ENABLED
5090 : impure module function getUnifRandRNGDLU_D3_SK3(lb, ub, s1, s2, s3) result(rand)
5091 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5092 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_SK3
5093 : #endif
5094 : use pm_kind, only: SKC => SK3
5095 : character(*,SKC) , intent(in) :: lb, ub
5096 : integer(IK) , intent(in) :: s1, s2, s3
5097 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
5098 : end function
5099 : #endif
5100 :
5101 : #if SK2_ENABLED
5102 : impure module function getUnifRandRNGDLU_D3_SK2(lb, ub, s1, s2, s3) result(rand)
5103 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5104 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_SK2
5105 : #endif
5106 : use pm_kind, only: SKC => SK2
5107 : character(*,SKC) , intent(in) :: lb, ub
5108 : integer(IK) , intent(in) :: s1, s2, s3
5109 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
5110 : end function
5111 : #endif
5112 :
5113 : #if SK1_ENABLED
5114 : impure module function getUnifRandRNGDLU_D3_SK1(lb, ub, s1, s2, s3) result(rand)
5115 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5116 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_SK1
5117 : #endif
5118 : use pm_kind, only: SKC => SK1
5119 : character(*,SKC) , intent(in) :: lb, ub
5120 : integer(IK) , intent(in) :: s1, s2, s3
5121 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
5122 : end function
5123 : #endif
5124 :
5125 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5126 :
5127 : #if IK5_ENABLED
5128 : impure module function getUnifRandRNGDLU_D3_IK5(lb, ub, s1, s2, s3) result(rand)
5129 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5130 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_IK5
5131 : #endif
5132 : use pm_kind, only: IKC => IK5
5133 : integer(IKC) , intent(in) :: lb, ub
5134 : integer(IK) , intent(in) :: s1, s2, s3
5135 : integer(IKC) :: rand(s1, s2, s3)
5136 : end function
5137 : #endif
5138 :
5139 : #if IK4_ENABLED
5140 : impure module function getUnifRandRNGDLU_D3_IK4(lb, ub, s1, s2, s3) result(rand)
5141 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5142 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_IK4
5143 : #endif
5144 : use pm_kind, only: IKC => IK4
5145 : integer(IKC) , intent(in) :: lb, ub
5146 : integer(IK) , intent(in) :: s1, s2, s3
5147 : integer(IKC) :: rand(s1, s2, s3)
5148 : end function
5149 : #endif
5150 :
5151 : #if IK3_ENABLED
5152 : impure module function getUnifRandRNGDLU_D3_IK3(lb, ub, s1, s2, s3) result(rand)
5153 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5154 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_IK3
5155 : #endif
5156 : use pm_kind, only: IKC => IK3
5157 : integer(IKC) , intent(in) :: lb, ub
5158 : integer(IK) , intent(in) :: s1, s2, s3
5159 : integer(IKC) :: rand(s1, s2, s3)
5160 : end function
5161 : #endif
5162 :
5163 : #if IK2_ENABLED
5164 : impure module function getUnifRandRNGDLU_D3_IK2(lb, ub, s1, s2, s3) result(rand)
5165 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5166 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_IK2
5167 : #endif
5168 : use pm_kind, only: IKC => IK2
5169 : integer(IKC) , intent(in) :: lb, ub
5170 : integer(IK) , intent(in) :: s1, s2, s3
5171 : integer(IKC) :: rand(s1, s2, s3)
5172 : end function
5173 : #endif
5174 :
5175 : #if IK1_ENABLED
5176 : impure module function getUnifRandRNGDLU_D3_IK1(lb, ub, s1, s2, s3) result(rand)
5177 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5178 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_IK1
5179 : #endif
5180 : use pm_kind, only: IKC => IK1
5181 : integer(IKC) , intent(in) :: lb, ub
5182 : integer(IK) , intent(in) :: s1, s2, s3
5183 : integer(IKC) :: rand(s1, s2, s3)
5184 : end function
5185 : #endif
5186 :
5187 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5188 :
5189 : #if LK5_ENABLED
5190 : impure module function getUnifRandRNGDLU_D3_LK5(lb, ub, s1, s2, s3) result(rand)
5191 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5192 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_LK5
5193 : #endif
5194 : use pm_kind, only: LKC => LK5
5195 : logical(LKC) , intent(in) :: lb, ub
5196 : integer(IK) , intent(in) :: s1, s2, s3
5197 : logical(LKC) :: rand(s1, s2, s3)
5198 : end function
5199 : #endif
5200 :
5201 : #if LK4_ENABLED
5202 : impure module function getUnifRandRNGDLU_D3_LK4(lb, ub, s1, s2, s3) result(rand)
5203 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5204 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_LK4
5205 : #endif
5206 : use pm_kind, only: LKC => LK4
5207 : logical(LKC) , intent(in) :: lb, ub
5208 : integer(IK) , intent(in) :: s1, s2, s3
5209 : logical(LKC) :: rand(s1, s2, s3)
5210 : end function
5211 : #endif
5212 :
5213 : #if LK3_ENABLED
5214 : impure module function getUnifRandRNGDLU_D3_LK3(lb, ub, s1, s2, s3) result(rand)
5215 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5216 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_LK3
5217 : #endif
5218 : use pm_kind, only: LKC => LK3
5219 : logical(LKC) , intent(in) :: lb, ub
5220 : integer(IK) , intent(in) :: s1, s2, s3
5221 : logical(LKC) :: rand(s1, s2, s3)
5222 : end function
5223 : #endif
5224 :
5225 : #if LK2_ENABLED
5226 : impure module function getUnifRandRNGDLU_D3_LK2(lb, ub, s1, s2, s3) result(rand)
5227 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5228 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_LK2
5229 : #endif
5230 : use pm_kind, only: LKC => LK2
5231 : logical(LKC) , intent(in) :: lb, ub
5232 : integer(IK) , intent(in) :: s1, s2, s3
5233 : logical(LKC) :: rand(s1, s2, s3)
5234 : end function
5235 : #endif
5236 :
5237 : #if LK1_ENABLED
5238 : impure module function getUnifRandRNGDLU_D3_LK1(lb, ub, s1, s2, s3) result(rand)
5239 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5240 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_LK1
5241 : #endif
5242 : use pm_kind, only: LKC => LK1
5243 : logical(LKC) , intent(in) :: lb, ub
5244 : integer(IK) , intent(in) :: s1, s2, s3
5245 : logical(LKC) :: rand(s1, s2, s3)
5246 : end function
5247 : #endif
5248 :
5249 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5250 :
5251 : #if CK5_ENABLED
5252 : impure module function getUnifRandRNGDLU_D3_CK5(lb, ub, s1, s2, s3) result(rand)
5253 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5254 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_CK5
5255 : #endif
5256 : use pm_kind, only: CKC => CK5
5257 : complex(CKC) , intent(in) :: lb, ub
5258 : integer(IK) , intent(in) :: s1, s2, s3
5259 : complex(CKC) :: rand(s1, s2, s3)
5260 : end function
5261 : #endif
5262 :
5263 : #if CK4_ENABLED
5264 : impure module function getUnifRandRNGDLU_D3_CK4(lb, ub, s1, s2, s3) result(rand)
5265 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5266 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_CK4
5267 : #endif
5268 : use pm_kind, only: CKC => CK4
5269 : complex(CKC) , intent(in) :: lb, ub
5270 : integer(IK) , intent(in) :: s1, s2, s3
5271 : complex(CKC) :: rand(s1, s2, s3)
5272 : end function
5273 : #endif
5274 :
5275 : #if CK3_ENABLED
5276 : impure module function getUnifRandRNGDLU_D3_CK3(lb, ub, s1, s2, s3) result(rand)
5277 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5278 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_CK3
5279 : #endif
5280 : use pm_kind, only: CKC => CK3
5281 : complex(CKC) , intent(in) :: lb, ub
5282 : integer(IK) , intent(in) :: s1, s2, s3
5283 : complex(CKC) :: rand(s1, s2, s3)
5284 : end function
5285 : #endif
5286 :
5287 : #if CK2_ENABLED
5288 : impure module function getUnifRandRNGDLU_D3_CK2(lb, ub, s1, s2, s3) result(rand)
5289 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5290 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_CK2
5291 : #endif
5292 : use pm_kind, only: CKC => CK2
5293 : complex(CKC) , intent(in) :: lb, ub
5294 : integer(IK) , intent(in) :: s1, s2, s3
5295 : complex(CKC) :: rand(s1, s2, s3)
5296 : end function
5297 : #endif
5298 :
5299 : #if CK1_ENABLED
5300 : impure module function getUnifRandRNGDLU_D3_CK1(lb, ub, s1, s2, s3) result(rand)
5301 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5302 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_CK1
5303 : #endif
5304 : use pm_kind, only: CKC => CK1
5305 : complex(CKC) , intent(in) :: lb, ub
5306 : integer(IK) , intent(in) :: s1, s2, s3
5307 : complex(CKC) :: rand(s1, s2, s3)
5308 : end function
5309 : #endif
5310 :
5311 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5312 :
5313 : #if RK5_ENABLED
5314 : impure module function getUnifRandRNGDLU_D3_RK5(lb, ub, s1, s2, s3) result(rand)
5315 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5316 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_RK5
5317 : #endif
5318 : use pm_kind, only: RKC => RK5
5319 : real(RKC) , intent(in) :: lb, ub
5320 : integer(IK) , intent(in) :: s1, s2, s3
5321 : real(RKC) :: rand(s1, s2, s3)
5322 : end function
5323 :
5324 : #endif
5325 :
5326 : #if RK4_ENABLED
5327 : impure module function getUnifRandRNGDLU_D3_RK4(lb, ub, s1, s2, s3) result(rand)
5328 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5329 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_RK4
5330 : #endif
5331 : use pm_kind, only: RKC => RK4
5332 : real(RKC) , intent(in) :: lb, ub
5333 : integer(IK) , intent(in) :: s1, s2, s3
5334 : real(RKC) :: rand(s1, s2, s3)
5335 : end function
5336 :
5337 : #endif
5338 :
5339 : #if RK3_ENABLED
5340 : impure module function getUnifRandRNGDLU_D3_RK3(lb, ub, s1, s2, s3) result(rand)
5341 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5342 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_RK3
5343 : #endif
5344 : use pm_kind, only: RKC => RK3
5345 : real(RKC) , intent(in) :: lb, ub
5346 : integer(IK) , intent(in) :: s1, s2, s3
5347 : real(RKC) :: rand(s1, s2, s3)
5348 : end function
5349 :
5350 : #endif
5351 :
5352 : #if RK2_ENABLED
5353 : impure module function getUnifRandRNGDLU_D3_RK2(lb, ub, s1, s2, s3) result(rand)
5354 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5355 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_RK2
5356 : #endif
5357 : use pm_kind, only: RKC => RK2
5358 : real(RKC) , intent(in) :: lb, ub
5359 : integer(IK) , intent(in) :: s1, s2, s3
5360 : real(RKC) :: rand(s1, s2, s3)
5361 : end function
5362 : #endif
5363 :
5364 : #if RK1_ENABLED
5365 : impure module function getUnifRandRNGDLU_D3_RK1(lb, ub, s1, s2, s3) result(rand)
5366 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5367 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGDLU_D3_RK1
5368 : #endif
5369 : use pm_kind, only: RKC => RK1
5370 : real(RKC) , intent(in) :: lb, ub
5371 : integer(IK) , intent(in) :: s1, s2, s3
5372 : real(RKC) :: rand(s1, s2, s3)
5373 : end function
5374 : #endif
5375 :
5376 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5377 :
5378 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5379 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5380 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5381 :
5382 : end interface
5383 :
5384 : ! RNGF
5385 :
5386 : interface getUnifRand
5387 :
5388 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5389 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5390 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5391 :
5392 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5393 :
5394 : impure module function getUnifRandRNGFDD_D0_LK(rng) result(rand)
5395 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5396 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFDD_D0_LK
5397 : #endif
5398 : use pm_kind, only: LKC => LK
5399 : logical(LKC) :: rand
5400 : type(rngf_type) , intent(inout) :: rng
5401 : end function
5402 :
5403 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5404 :
5405 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5406 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5407 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5408 :
5409 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5410 :
5411 : #if SK5_ENABLED
5412 : impure elemental module function getUnifRandRNGFLU_D0_SK5(rng, lb, ub) result(rand)
5413 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5414 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_SK5
5415 : #endif
5416 : use pm_kind, only: SKC => SK5
5417 : character(*,SKC) , intent(in) :: lb, ub
5418 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
5419 : type(rngf_type) , intent(inout) :: rng
5420 : end function
5421 : #endif
5422 :
5423 : #if SK4_ENABLED
5424 : impure elemental module function getUnifRandRNGFLU_D0_SK4(rng, lb, ub) result(rand)
5425 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5426 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_SK4
5427 : #endif
5428 : use pm_kind, only: SKC => SK4
5429 : character(*,SKC) , intent(in) :: lb, ub
5430 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
5431 : type(rngf_type) , intent(inout) :: rng
5432 : end function
5433 : #endif
5434 :
5435 : #if SK3_ENABLED
5436 : impure elemental module function getUnifRandRNGFLU_D0_SK3(rng, lb, ub) result(rand)
5437 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5438 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_SK3
5439 : #endif
5440 : use pm_kind, only: SKC => SK3
5441 : character(*,SKC) , intent(in) :: lb, ub
5442 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
5443 : type(rngf_type) , intent(inout) :: rng
5444 : end function
5445 : #endif
5446 :
5447 : #if SK2_ENABLED
5448 : impure elemental module function getUnifRandRNGFLU_D0_SK2(rng, lb, ub) result(rand)
5449 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5450 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_SK2
5451 : #endif
5452 : use pm_kind, only: SKC => SK2
5453 : character(*,SKC) , intent(in) :: lb, ub
5454 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
5455 : type(rngf_type) , intent(inout) :: rng
5456 : end function
5457 : #endif
5458 :
5459 : #if SK1_ENABLED
5460 : impure elemental module function getUnifRandRNGFLU_D0_SK1(rng, lb, ub) result(rand)
5461 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5462 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_SK1
5463 : #endif
5464 : use pm_kind, only: SKC => SK1
5465 : character(*,SKC) , intent(in) :: lb, ub
5466 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
5467 : type(rngf_type) , intent(inout) :: rng
5468 : end function
5469 : #endif
5470 :
5471 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5472 :
5473 : #if IK5_ENABLED
5474 : impure elemental module function getUnifRandRNGFLU_D0_IK5(rng, lb, ub) result(rand)
5475 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5476 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_IK5
5477 : #endif
5478 : use pm_kind, only: IKC => IK5
5479 : integer(IKC) , intent(in) :: lb, ub
5480 : integer(IKC) :: rand
5481 : type(rngf_type) , intent(inout) :: rng
5482 : end function
5483 : #endif
5484 :
5485 : #if IK4_ENABLED
5486 : impure elemental module function getUnifRandRNGFLU_D0_IK4(rng, lb, ub) result(rand)
5487 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5488 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_IK4
5489 : #endif
5490 : use pm_kind, only: IKC => IK4
5491 : integer(IKC) , intent(in) :: lb, ub
5492 : integer(IKC) :: rand
5493 : type(rngf_type) , intent(inout) :: rng
5494 : end function
5495 : #endif
5496 :
5497 : #if IK3_ENABLED
5498 : impure elemental module function getUnifRandRNGFLU_D0_IK3(rng, lb, ub) result(rand)
5499 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5500 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_IK3
5501 : #endif
5502 : use pm_kind, only: IKC => IK3
5503 : integer(IKC) , intent(in) :: lb, ub
5504 : integer(IKC) :: rand
5505 : type(rngf_type) , intent(inout) :: rng
5506 : end function
5507 : #endif
5508 :
5509 : #if IK2_ENABLED
5510 : impure elemental module function getUnifRandRNGFLU_D0_IK2(rng, lb, ub) result(rand)
5511 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5512 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_IK2
5513 : #endif
5514 : use pm_kind, only: IKC => IK2
5515 : integer(IKC) , intent(in) :: lb, ub
5516 : integer(IKC) :: rand
5517 : type(rngf_type) , intent(inout) :: rng
5518 : end function
5519 : #endif
5520 :
5521 : #if IK1_ENABLED
5522 : impure elemental module function getUnifRandRNGFLU_D0_IK1(rng, lb, ub) result(rand)
5523 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5524 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_IK1
5525 : #endif
5526 : use pm_kind, only: IKC => IK1
5527 : integer(IKC) , intent(in) :: lb, ub
5528 : integer(IKC) :: rand
5529 : type(rngf_type) , intent(inout) :: rng
5530 : end function
5531 : #endif
5532 :
5533 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5534 :
5535 : #if LK5_ENABLED
5536 : impure elemental module function getUnifRandRNGFLU_D0_LK5(rng, lb, ub) result(rand)
5537 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5538 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_LK5
5539 : #endif
5540 : use pm_kind, only: LKC => LK5
5541 : logical(LKC) , intent(in) :: lb, ub
5542 : logical(LKC) :: rand
5543 : type(rngf_type) , intent(inout) :: rng
5544 : end function
5545 : #endif
5546 :
5547 : #if LK4_ENABLED
5548 : impure elemental module function getUnifRandRNGFLU_D0_LK4(rng, lb, ub) result(rand)
5549 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5550 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_LK4
5551 : #endif
5552 : use pm_kind, only: LKC => LK4
5553 : logical(LKC) , intent(in) :: lb, ub
5554 : logical(LKC) :: rand
5555 : type(rngf_type) , intent(inout) :: rng
5556 : end function
5557 : #endif
5558 :
5559 : #if LK3_ENABLED
5560 : impure elemental module function getUnifRandRNGFLU_D0_LK3(rng, lb, ub) result(rand)
5561 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5562 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_LK3
5563 : #endif
5564 : use pm_kind, only: LKC => LK3
5565 : logical(LKC) , intent(in) :: lb, ub
5566 : logical(LKC) :: rand
5567 : type(rngf_type) , intent(inout) :: rng
5568 : end function
5569 : #endif
5570 :
5571 : #if LK2_ENABLED
5572 : impure elemental module function getUnifRandRNGFLU_D0_LK2(rng, lb, ub) result(rand)
5573 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5574 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_LK2
5575 : #endif
5576 : use pm_kind, only: LKC => LK2
5577 : logical(LKC) , intent(in) :: lb, ub
5578 : logical(LKC) :: rand
5579 : type(rngf_type) , intent(inout) :: rng
5580 : end function
5581 : #endif
5582 :
5583 : #if LK1_ENABLED
5584 : impure elemental module function getUnifRandRNGFLU_D0_LK1(rng, lb, ub) result(rand)
5585 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5586 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_LK1
5587 : #endif
5588 : use pm_kind, only: LKC => LK1
5589 : logical(LKC) , intent(in) :: lb, ub
5590 : logical(LKC) :: rand
5591 : type(rngf_type) , intent(inout) :: rng
5592 : end function
5593 : #endif
5594 :
5595 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5596 :
5597 : #if CK5_ENABLED
5598 : impure elemental module function getUnifRandRNGFLU_D0_CK5(rng, lb, ub) result(rand)
5599 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5600 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_CK5
5601 : #endif
5602 : use pm_kind, only: CKC => CK5
5603 : complex(CKC) , intent(in) :: lb, ub
5604 : complex(CKC) :: rand
5605 : type(rngf_type) , intent(inout) :: rng
5606 : end function
5607 : #endif
5608 :
5609 : #if CK4_ENABLED
5610 : impure elemental module function getUnifRandRNGFLU_D0_CK4(rng, lb, ub) result(rand)
5611 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5612 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_CK4
5613 : #endif
5614 : use pm_kind, only: CKC => CK4
5615 : complex(CKC) , intent(in) :: lb, ub
5616 : complex(CKC) :: rand
5617 : type(rngf_type) , intent(inout) :: rng
5618 : end function
5619 : #endif
5620 :
5621 : #if CK3_ENABLED
5622 : impure elemental module function getUnifRandRNGFLU_D0_CK3(rng, lb, ub) result(rand)
5623 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5624 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_CK3
5625 : #endif
5626 : use pm_kind, only: CKC => CK3
5627 : complex(CKC) , intent(in) :: lb, ub
5628 : complex(CKC) :: rand
5629 : type(rngf_type) , intent(inout) :: rng
5630 : end function
5631 : #endif
5632 :
5633 : #if CK2_ENABLED
5634 : impure elemental module function getUnifRandRNGFLU_D0_CK2(rng, lb, ub) result(rand)
5635 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5636 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_CK2
5637 : #endif
5638 : use pm_kind, only: CKC => CK2
5639 : complex(CKC) , intent(in) :: lb, ub
5640 : complex(CKC) :: rand
5641 : type(rngf_type) , intent(inout) :: rng
5642 : end function
5643 : #endif
5644 :
5645 : #if CK1_ENABLED
5646 : impure elemental module function getUnifRandRNGFLU_D0_CK1(rng, lb, ub) result(rand)
5647 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5648 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_CK1
5649 : #endif
5650 : use pm_kind, only: CKC => CK1
5651 : complex(CKC) , intent(in) :: lb, ub
5652 : complex(CKC) :: rand
5653 : type(rngf_type) , intent(inout) :: rng
5654 : end function
5655 : #endif
5656 :
5657 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5658 :
5659 : #if RK5_ENABLED
5660 : impure elemental module function getUnifRandRNGFLU_D0_RK5(rng, lb, ub) result(rand)
5661 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5662 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_RK5
5663 : #endif
5664 : use pm_kind, only: RKC => RK5
5665 : real(RKC) , intent(in) :: lb, ub
5666 : real(RKC) :: rand
5667 : type(rngf_type) , intent(inout) :: rng
5668 : end function
5669 : #endif
5670 :
5671 : #if RK4_ENABLED
5672 : impure elemental module function getUnifRandRNGFLU_D0_RK4(rng, lb, ub) result(rand)
5673 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5674 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_RK4
5675 : #endif
5676 : use pm_kind, only: RKC => RK4
5677 : real(RKC) , intent(in) :: lb, ub
5678 : real(RKC) :: rand
5679 : type(rngf_type) , intent(inout) :: rng
5680 : end function
5681 : #endif
5682 :
5683 : #if RK3_ENABLED
5684 : impure elemental module function getUnifRandRNGFLU_D0_RK3(rng, lb, ub) result(rand)
5685 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5686 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_RK3
5687 : #endif
5688 : use pm_kind, only: RKC => RK3
5689 : real(RKC) , intent(in) :: lb, ub
5690 : real(RKC) :: rand
5691 : type(rngf_type) , intent(inout) :: rng
5692 : end function
5693 : #endif
5694 :
5695 : #if RK2_ENABLED
5696 : impure elemental module function getUnifRandRNGFLU_D0_RK2(rng, lb, ub) result(rand)
5697 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5698 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_RK2
5699 : #endif
5700 : use pm_kind, only: RKC => RK2
5701 : real(RKC) , intent(in) :: lb, ub
5702 : real(RKC) :: rand
5703 : type(rngf_type) , intent(inout) :: rng
5704 : end function
5705 : #endif
5706 :
5707 : #if RK1_ENABLED
5708 : impure elemental module function getUnifRandRNGFLU_D0_RK1(rng, lb, ub) result(rand)
5709 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5710 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D0_RK1
5711 : #endif
5712 : use pm_kind, only: RKC => RK1
5713 : real(RKC) , intent(in) :: lb, ub
5714 : real(RKC) :: rand
5715 : type(rngf_type) , intent(inout) :: rng
5716 : end function
5717 : #endif
5718 :
5719 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5720 :
5721 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5722 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5723 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5724 :
5725 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5726 :
5727 : #if SK5_ENABLED
5728 : impure module function getUnifRandRNGFLU_D1_SK5(rng, lb, ub, s1) result(rand)
5729 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5730 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_SK5
5731 : #endif
5732 : use pm_kind, only: SKC => SK5
5733 : character(*,SKC) , intent(in) :: lb, ub
5734 : integer(IK) , intent(in) :: s1
5735 : character(len(lb,IK),SKC) :: rand(s1)
5736 : type(rngf_type) , intent(inout) :: rng
5737 : end function
5738 : #endif
5739 :
5740 : #if SK4_ENABLED
5741 : impure module function getUnifRandRNGFLU_D1_SK4(rng, lb, ub, s1) result(rand)
5742 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5743 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_SK4
5744 : #endif
5745 : use pm_kind, only: SKC => SK4
5746 : character(*,SKC) , intent(in) :: lb, ub
5747 : integer(IK) , intent(in) :: s1
5748 : character(len(lb,IK),SKC) :: rand(s1)
5749 : type(rngf_type) , intent(inout) :: rng
5750 : end function
5751 : #endif
5752 :
5753 : #if SK3_ENABLED
5754 : impure module function getUnifRandRNGFLU_D1_SK3(rng, lb, ub, s1) result(rand)
5755 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5756 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_SK3
5757 : #endif
5758 : use pm_kind, only: SKC => SK3
5759 : character(*,SKC) , intent(in) :: lb, ub
5760 : integer(IK) , intent(in) :: s1
5761 : character(len(lb,IK),SKC) :: rand(s1)
5762 : type(rngf_type) , intent(inout) :: rng
5763 : end function
5764 : #endif
5765 :
5766 : #if SK2_ENABLED
5767 : impure module function getUnifRandRNGFLU_D1_SK2(rng, lb, ub, s1) result(rand)
5768 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5769 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_SK2
5770 : #endif
5771 : use pm_kind, only: SKC => SK2
5772 : character(*,SKC) , intent(in) :: lb, ub
5773 : integer(IK) , intent(in) :: s1
5774 : character(len(lb,IK),SKC) :: rand(s1)
5775 : type(rngf_type) , intent(inout) :: rng
5776 : end function
5777 : #endif
5778 :
5779 : #if SK1_ENABLED
5780 : impure module function getUnifRandRNGFLU_D1_SK1(rng, lb, ub, s1) result(rand)
5781 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5782 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_SK1
5783 : #endif
5784 : use pm_kind, only: SKC => SK1
5785 : character(*,SKC) , intent(in) :: lb, ub
5786 : integer(IK) , intent(in) :: s1
5787 : character(len(lb,IK),SKC) :: rand(s1)
5788 : type(rngf_type) , intent(inout) :: rng
5789 : end function
5790 : #endif
5791 :
5792 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5793 :
5794 : #if IK5_ENABLED
5795 : impure module function getUnifRandRNGFLU_D1_IK5(rng, lb, ub, s1) result(rand)
5796 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5797 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_IK5
5798 : #endif
5799 : use pm_kind, only: IKC => IK5
5800 : integer(IKC) , intent(in) :: lb, ub
5801 : integer(IK) , intent(in) :: s1
5802 : integer(IKC) :: rand(s1)
5803 : type(rngf_type) , intent(inout) :: rng
5804 : end function
5805 : #endif
5806 :
5807 : #if IK4_ENABLED
5808 : impure module function getUnifRandRNGFLU_D1_IK4(rng, lb, ub, s1) result(rand)
5809 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5810 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_IK4
5811 : #endif
5812 : use pm_kind, only: IKC => IK4
5813 : integer(IKC) , intent(in) :: lb, ub
5814 : integer(IK) , intent(in) :: s1
5815 : integer(IKC) :: rand(s1)
5816 : type(rngf_type) , intent(inout) :: rng
5817 : end function
5818 : #endif
5819 :
5820 : #if IK3_ENABLED
5821 : impure module function getUnifRandRNGFLU_D1_IK3(rng, lb, ub, s1) result(rand)
5822 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5823 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_IK3
5824 : #endif
5825 : use pm_kind, only: IKC => IK3
5826 : integer(IKC) , intent(in) :: lb, ub
5827 : integer(IK) , intent(in) :: s1
5828 : integer(IKC) :: rand(s1)
5829 : type(rngf_type) , intent(inout) :: rng
5830 : end function
5831 : #endif
5832 :
5833 : #if IK2_ENABLED
5834 : impure module function getUnifRandRNGFLU_D1_IK2(rng, lb, ub, s1) result(rand)
5835 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5836 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_IK2
5837 : #endif
5838 : use pm_kind, only: IKC => IK2
5839 : integer(IKC) , intent(in) :: lb, ub
5840 : integer(IK) , intent(in) :: s1
5841 : integer(IKC) :: rand(s1)
5842 : type(rngf_type) , intent(inout) :: rng
5843 : end function
5844 : #endif
5845 :
5846 : #if IK1_ENABLED
5847 : impure module function getUnifRandRNGFLU_D1_IK1(rng, lb, ub, s1) result(rand)
5848 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5849 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_IK1
5850 : #endif
5851 : use pm_kind, only: IKC => IK1
5852 : integer(IKC) , intent(in) :: lb, ub
5853 : integer(IK) , intent(in) :: s1
5854 : integer(IKC) :: rand(s1)
5855 : type(rngf_type) , intent(inout) :: rng
5856 : end function
5857 : #endif
5858 :
5859 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5860 :
5861 : #if LK5_ENABLED
5862 : impure module function getUnifRandRNGFLU_D1_LK5(rng, lb, ub, s1) result(rand)
5863 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5864 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_LK5
5865 : #endif
5866 : use pm_kind, only: LKC => LK5
5867 : logical(LKC) , intent(in) :: lb, ub
5868 : integer(IK) , intent(in) :: s1
5869 : logical(LKC) :: rand(s1)
5870 : type(rngf_type) , intent(inout) :: rng
5871 : end function
5872 : #endif
5873 :
5874 : #if LK4_ENABLED
5875 : impure module function getUnifRandRNGFLU_D1_LK4(rng, lb, ub, s1) result(rand)
5876 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5877 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_LK4
5878 : #endif
5879 : use pm_kind, only: LKC => LK4
5880 : logical(LKC) , intent(in) :: lb, ub
5881 : integer(IK) , intent(in) :: s1
5882 : logical(LKC) :: rand(s1)
5883 : type(rngf_type) , intent(inout) :: rng
5884 : end function
5885 : #endif
5886 :
5887 : #if LK3_ENABLED
5888 : impure module function getUnifRandRNGFLU_D1_LK3(rng, lb, ub, s1) result(rand)
5889 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5890 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_LK3
5891 : #endif
5892 : use pm_kind, only: LKC => LK3
5893 : logical(LKC) , intent(in) :: lb, ub
5894 : integer(IK) , intent(in) :: s1
5895 : logical(LKC) :: rand(s1)
5896 : type(rngf_type) , intent(inout) :: rng
5897 : end function
5898 : #endif
5899 :
5900 : #if LK2_ENABLED
5901 : impure module function getUnifRandRNGFLU_D1_LK2(rng, lb, ub, s1) result(rand)
5902 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5903 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_LK2
5904 : #endif
5905 : use pm_kind, only: LKC => LK2
5906 : logical(LKC) , intent(in) :: lb, ub
5907 : integer(IK) , intent(in) :: s1
5908 : logical(LKC) :: rand(s1)
5909 : type(rngf_type) , intent(inout) :: rng
5910 : end function
5911 : #endif
5912 :
5913 : #if LK1_ENABLED
5914 : impure module function getUnifRandRNGFLU_D1_LK1(rng, lb, ub, s1) result(rand)
5915 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5916 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_LK1
5917 : #endif
5918 : use pm_kind, only: LKC => LK1
5919 : logical(LKC) , intent(in) :: lb, ub
5920 : integer(IK) , intent(in) :: s1
5921 : logical(LKC) :: rand(s1)
5922 : type(rngf_type) , intent(inout) :: rng
5923 : end function
5924 : #endif
5925 :
5926 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5927 :
5928 : #if CK5_ENABLED
5929 : impure module function getUnifRandRNGFLU_D1_CK5(rng, lb, ub, s1) result(rand)
5930 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5931 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_CK5
5932 : #endif
5933 : use pm_kind, only: CKC => CK5
5934 : complex(CKC) , intent(in) :: lb, ub
5935 : integer(IK) , intent(in) :: s1
5936 : complex(CKC) :: rand(s1)
5937 : type(rngf_type) , intent(inout) :: rng
5938 : end function
5939 : #endif
5940 :
5941 : #if CK4_ENABLED
5942 : impure module function getUnifRandRNGFLU_D1_CK4(rng, lb, ub, s1) result(rand)
5943 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5944 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_CK4
5945 : #endif
5946 : use pm_kind, only: CKC => CK4
5947 : complex(CKC) , intent(in) :: lb, ub
5948 : integer(IK) , intent(in) :: s1
5949 : complex(CKC) :: rand(s1)
5950 : type(rngf_type) , intent(inout) :: rng
5951 : end function
5952 : #endif
5953 :
5954 : #if CK3_ENABLED
5955 : impure module function getUnifRandRNGFLU_D1_CK3(rng, lb, ub, s1) result(rand)
5956 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5957 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_CK3
5958 : #endif
5959 : use pm_kind, only: CKC => CK3
5960 : complex(CKC) , intent(in) :: lb, ub
5961 : integer(IK) , intent(in) :: s1
5962 : complex(CKC) :: rand(s1)
5963 : type(rngf_type) , intent(inout) :: rng
5964 : end function
5965 : #endif
5966 :
5967 : #if CK2_ENABLED
5968 : impure module function getUnifRandRNGFLU_D1_CK2(rng, lb, ub, s1) result(rand)
5969 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5970 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_CK2
5971 : #endif
5972 : use pm_kind, only: CKC => CK2
5973 : complex(CKC) , intent(in) :: lb, ub
5974 : integer(IK) , intent(in) :: s1
5975 : complex(CKC) :: rand(s1)
5976 : type(rngf_type) , intent(inout) :: rng
5977 : end function
5978 : #endif
5979 :
5980 : #if CK1_ENABLED
5981 : impure module function getUnifRandRNGFLU_D1_CK1(rng, lb, ub, s1) result(rand)
5982 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5983 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_CK1
5984 : #endif
5985 : use pm_kind, only: CKC => CK1
5986 : complex(CKC) , intent(in) :: lb, ub
5987 : integer(IK) , intent(in) :: s1
5988 : complex(CKC) :: rand(s1)
5989 : type(rngf_type) , intent(inout) :: rng
5990 : end function
5991 : #endif
5992 :
5993 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5994 :
5995 : #if RK5_ENABLED
5996 : impure module function getUnifRandRNGFLU_D1_RK5(rng, lb, ub, s1) result(rand)
5997 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5998 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_RK5
5999 : #endif
6000 : use pm_kind, only: RKC => RK5
6001 : real(RKC) , intent(in) :: lb, ub
6002 : integer(IK) , intent(in) :: s1
6003 : real(RKC) :: rand(s1)
6004 : type(rngf_type) , intent(inout) :: rng
6005 : end function
6006 :
6007 : #endif
6008 :
6009 : #if RK4_ENABLED
6010 : impure module function getUnifRandRNGFLU_D1_RK4(rng, lb, ub, s1) result(rand)
6011 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6012 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_RK4
6013 : #endif
6014 : use pm_kind, only: RKC => RK4
6015 : real(RKC) , intent(in) :: lb, ub
6016 : integer(IK) , intent(in) :: s1
6017 : real(RKC) :: rand(s1)
6018 : type(rngf_type) , intent(inout) :: rng
6019 : end function
6020 :
6021 : #endif
6022 :
6023 : #if RK3_ENABLED
6024 : impure module function getUnifRandRNGFLU_D1_RK3(rng, lb, ub, s1) result(rand)
6025 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6026 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_RK3
6027 : #endif
6028 : use pm_kind, only: RKC => RK3
6029 : real(RKC) , intent(in) :: lb, ub
6030 : integer(IK) , intent(in) :: s1
6031 : real(RKC) :: rand(s1)
6032 : type(rngf_type) , intent(inout) :: rng
6033 : end function
6034 :
6035 : #endif
6036 :
6037 : #if RK2_ENABLED
6038 : impure module function getUnifRandRNGFLU_D1_RK2(rng, lb, ub, s1) result(rand)
6039 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6040 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_RK2
6041 : #endif
6042 : use pm_kind, only: RKC => RK2
6043 : real(RKC) , intent(in) :: lb, ub
6044 : integer(IK) , intent(in) :: s1
6045 : real(RKC) :: rand(s1)
6046 : type(rngf_type) , intent(inout) :: rng
6047 : end function
6048 : #endif
6049 :
6050 : #if RK1_ENABLED
6051 : impure module function getUnifRandRNGFLU_D1_RK1(rng, lb, ub, s1) result(rand)
6052 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6053 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D1_RK1
6054 : #endif
6055 : use pm_kind, only: RKC => RK1
6056 : real(RKC) , intent(in) :: lb, ub
6057 : integer(IK) , intent(in) :: s1
6058 : real(RKC) :: rand(s1)
6059 : type(rngf_type) , intent(inout) :: rng
6060 : end function
6061 : #endif
6062 :
6063 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6064 :
6065 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6066 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6067 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6068 :
6069 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6070 :
6071 : #if SK5_ENABLED
6072 : impure module function getUnifRandRNGFLU_D2_SK5(rng, lb, ub, s1, s2) result(rand)
6073 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6074 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_SK5
6075 : #endif
6076 : use pm_kind, only: SKC => SK5
6077 : character(*,SKC) , intent(in) :: lb, ub
6078 : integer(IK) , intent(in) :: s1, s2
6079 : character(len(lb,IK),SKC) :: rand(s1, s2)
6080 : type(rngf_type) , intent(inout) :: rng
6081 : end function
6082 : #endif
6083 :
6084 : #if SK4_ENABLED
6085 : impure module function getUnifRandRNGFLU_D2_SK4(rng, lb, ub, s1, s2) result(rand)
6086 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6087 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_SK4
6088 : #endif
6089 : use pm_kind, only: SKC => SK4
6090 : character(*,SKC) , intent(in) :: lb, ub
6091 : integer(IK) , intent(in) :: s1, s2
6092 : character(len(lb,IK),SKC) :: rand(s1, s2)
6093 : type(rngf_type) , intent(inout) :: rng
6094 : end function
6095 : #endif
6096 :
6097 : #if SK3_ENABLED
6098 : impure module function getUnifRandRNGFLU_D2_SK3(rng, lb, ub, s1, s2) result(rand)
6099 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6100 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_SK3
6101 : #endif
6102 : use pm_kind, only: SKC => SK3
6103 : character(*,SKC) , intent(in) :: lb, ub
6104 : integer(IK) , intent(in) :: s1, s2
6105 : character(len(lb,IK),SKC) :: rand(s1, s2)
6106 : type(rngf_type) , intent(inout) :: rng
6107 : end function
6108 : #endif
6109 :
6110 : #if SK2_ENABLED
6111 : impure module function getUnifRandRNGFLU_D2_SK2(rng, lb, ub, s1, s2) result(rand)
6112 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6113 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_SK2
6114 : #endif
6115 : use pm_kind, only: SKC => SK2
6116 : character(*,SKC) , intent(in) :: lb, ub
6117 : integer(IK) , intent(in) :: s1, s2
6118 : character(len(lb,IK),SKC) :: rand(s1, s2)
6119 : type(rngf_type) , intent(inout) :: rng
6120 : end function
6121 : #endif
6122 :
6123 : #if SK1_ENABLED
6124 : impure module function getUnifRandRNGFLU_D2_SK1(rng, lb, ub, s1, s2) result(rand)
6125 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6126 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_SK1
6127 : #endif
6128 : use pm_kind, only: SKC => SK1
6129 : character(*,SKC) , intent(in) :: lb, ub
6130 : integer(IK) , intent(in) :: s1, s2
6131 : character(len(lb,IK),SKC) :: rand(s1, s2)
6132 : type(rngf_type) , intent(inout) :: rng
6133 : end function
6134 : #endif
6135 :
6136 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6137 :
6138 : #if IK5_ENABLED
6139 : impure module function getUnifRandRNGFLU_D2_IK5(rng, lb, ub, s1, s2) result(rand)
6140 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6141 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_IK5
6142 : #endif
6143 : use pm_kind, only: IKC => IK5
6144 : integer(IKC) , intent(in) :: lb, ub
6145 : integer(IK) , intent(in) :: s1, s2
6146 : integer(IKC) :: rand(s1, s2)
6147 : type(rngf_type) , intent(inout) :: rng
6148 : end function
6149 : #endif
6150 :
6151 : #if IK4_ENABLED
6152 : impure module function getUnifRandRNGFLU_D2_IK4(rng, lb, ub, s1, s2) result(rand)
6153 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6154 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_IK4
6155 : #endif
6156 : use pm_kind, only: IKC => IK4
6157 : integer(IKC) , intent(in) :: lb, ub
6158 : integer(IK) , intent(in) :: s1, s2
6159 : integer(IKC) :: rand(s1, s2)
6160 : type(rngf_type) , intent(inout) :: rng
6161 : end function
6162 : #endif
6163 :
6164 : #if IK3_ENABLED
6165 : impure module function getUnifRandRNGFLU_D2_IK3(rng, lb, ub, s1, s2) result(rand)
6166 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6167 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_IK3
6168 : #endif
6169 : use pm_kind, only: IKC => IK3
6170 : integer(IKC) , intent(in) :: lb, ub
6171 : integer(IK) , intent(in) :: s1, s2
6172 : integer(IKC) :: rand(s1, s2)
6173 : type(rngf_type) , intent(inout) :: rng
6174 : end function
6175 : #endif
6176 :
6177 : #if IK2_ENABLED
6178 : impure module function getUnifRandRNGFLU_D2_IK2(rng, lb, ub, s1, s2) result(rand)
6179 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6180 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_IK2
6181 : #endif
6182 : use pm_kind, only: IKC => IK2
6183 : integer(IKC) , intent(in) :: lb, ub
6184 : integer(IK) , intent(in) :: s1, s2
6185 : integer(IKC) :: rand(s1, s2)
6186 : type(rngf_type) , intent(inout) :: rng
6187 : end function
6188 : #endif
6189 :
6190 : #if IK1_ENABLED
6191 : impure module function getUnifRandRNGFLU_D2_IK1(rng, lb, ub, s1, s2) result(rand)
6192 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6193 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_IK1
6194 : #endif
6195 : use pm_kind, only: IKC => IK1
6196 : integer(IKC) , intent(in) :: lb, ub
6197 : integer(IK) , intent(in) :: s1, s2
6198 : integer(IKC) :: rand(s1, s2)
6199 : type(rngf_type) , intent(inout) :: rng
6200 : end function
6201 : #endif
6202 :
6203 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6204 :
6205 : #if LK5_ENABLED
6206 : impure module function getUnifRandRNGFLU_D2_LK5(rng, lb, ub, s1, s2) result(rand)
6207 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6208 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_LK5
6209 : #endif
6210 : use pm_kind, only: LKC => LK5
6211 : logical(LKC) , intent(in) :: lb, ub
6212 : integer(IK) , intent(in) :: s1, s2
6213 : logical(LKC) :: rand(s1, s2)
6214 : type(rngf_type) , intent(inout) :: rng
6215 : end function
6216 : #endif
6217 :
6218 : #if LK4_ENABLED
6219 : impure module function getUnifRandRNGFLU_D2_LK4(rng, lb, ub, s1, s2) result(rand)
6220 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6221 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_LK4
6222 : #endif
6223 : use pm_kind, only: LKC => LK4
6224 : logical(LKC) , intent(in) :: lb, ub
6225 : integer(IK) , intent(in) :: s1, s2
6226 : logical(LKC) :: rand(s1, s2)
6227 : type(rngf_type) , intent(inout) :: rng
6228 : end function
6229 : #endif
6230 :
6231 : #if LK3_ENABLED
6232 : impure module function getUnifRandRNGFLU_D2_LK3(rng, lb, ub, s1, s2) result(rand)
6233 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6234 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_LK3
6235 : #endif
6236 : use pm_kind, only: LKC => LK3
6237 : logical(LKC) , intent(in) :: lb, ub
6238 : integer(IK) , intent(in) :: s1, s2
6239 : logical(LKC) :: rand(s1, s2)
6240 : type(rngf_type) , intent(inout) :: rng
6241 : end function
6242 : #endif
6243 :
6244 : #if LK2_ENABLED
6245 : impure module function getUnifRandRNGFLU_D2_LK2(rng, lb, ub, s1, s2) result(rand)
6246 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6247 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_LK2
6248 : #endif
6249 : use pm_kind, only: LKC => LK2
6250 : logical(LKC) , intent(in) :: lb, ub
6251 : integer(IK) , intent(in) :: s1, s2
6252 : logical(LKC) :: rand(s1, s2)
6253 : type(rngf_type) , intent(inout) :: rng
6254 : end function
6255 : #endif
6256 :
6257 : #if LK1_ENABLED
6258 : impure module function getUnifRandRNGFLU_D2_LK1(rng, lb, ub, s1, s2) result(rand)
6259 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6260 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_LK1
6261 : #endif
6262 : use pm_kind, only: LKC => LK1
6263 : logical(LKC) , intent(in) :: lb, ub
6264 : integer(IK) , intent(in) :: s1, s2
6265 : logical(LKC) :: rand(s1, s2)
6266 : type(rngf_type) , intent(inout) :: rng
6267 : end function
6268 : #endif
6269 :
6270 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6271 :
6272 : #if CK5_ENABLED
6273 : impure module function getUnifRandRNGFLU_D2_CK5(rng, lb, ub, s1, s2) result(rand)
6274 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6275 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_CK5
6276 : #endif
6277 : use pm_kind, only: CKC => CK5
6278 : complex(CKC) , intent(in) :: lb, ub
6279 : integer(IK) , intent(in) :: s1, s2
6280 : complex(CKC) :: rand(s1, s2)
6281 : type(rngf_type) , intent(inout) :: rng
6282 : end function
6283 : #endif
6284 :
6285 : #if CK4_ENABLED
6286 : impure module function getUnifRandRNGFLU_D2_CK4(rng, lb, ub, s1, s2) result(rand)
6287 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6288 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_CK4
6289 : #endif
6290 : use pm_kind, only: CKC => CK4
6291 : complex(CKC) , intent(in) :: lb, ub
6292 : integer(IK) , intent(in) :: s1, s2
6293 : complex(CKC) :: rand(s1, s2)
6294 : type(rngf_type) , intent(inout) :: rng
6295 : end function
6296 : #endif
6297 :
6298 : #if CK3_ENABLED
6299 : impure module function getUnifRandRNGFLU_D2_CK3(rng, lb, ub, s1, s2) result(rand)
6300 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6301 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_CK3
6302 : #endif
6303 : use pm_kind, only: CKC => CK3
6304 : complex(CKC) , intent(in) :: lb, ub
6305 : integer(IK) , intent(in) :: s1, s2
6306 : complex(CKC) :: rand(s1, s2)
6307 : type(rngf_type) , intent(inout) :: rng
6308 : end function
6309 : #endif
6310 :
6311 : #if CK2_ENABLED
6312 : impure module function getUnifRandRNGFLU_D2_CK2(rng, lb, ub, s1, s2) result(rand)
6313 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6314 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_CK2
6315 : #endif
6316 : use pm_kind, only: CKC => CK2
6317 : complex(CKC) , intent(in) :: lb, ub
6318 : integer(IK) , intent(in) :: s1, s2
6319 : complex(CKC) :: rand(s1, s2)
6320 : type(rngf_type) , intent(inout) :: rng
6321 : end function
6322 : #endif
6323 :
6324 : #if CK1_ENABLED
6325 : impure module function getUnifRandRNGFLU_D2_CK1(rng, lb, ub, s1, s2) result(rand)
6326 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6327 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_CK1
6328 : #endif
6329 : use pm_kind, only: CKC => CK1
6330 : complex(CKC) , intent(in) :: lb, ub
6331 : integer(IK) , intent(in) :: s1, s2
6332 : complex(CKC) :: rand(s1, s2)
6333 : type(rngf_type) , intent(inout) :: rng
6334 : end function
6335 : #endif
6336 :
6337 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6338 :
6339 : #if RK5_ENABLED
6340 : impure module function getUnifRandRNGFLU_D2_RK5(rng, lb, ub, s1, s2) result(rand)
6341 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6342 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_RK5
6343 : #endif
6344 : use pm_kind, only: RKC => RK5
6345 : real(RKC) , intent(in) :: lb, ub
6346 : integer(IK) , intent(in) :: s1, s2
6347 : real(RKC) :: rand(s1, s2)
6348 : type(rngf_type) , intent(inout) :: rng
6349 : end function
6350 :
6351 : #endif
6352 :
6353 : #if RK4_ENABLED
6354 : impure module function getUnifRandRNGFLU_D2_RK4(rng, lb, ub, s1, s2) result(rand)
6355 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6356 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_RK4
6357 : #endif
6358 : use pm_kind, only: RKC => RK4
6359 : real(RKC) , intent(in) :: lb, ub
6360 : integer(IK) , intent(in) :: s1, s2
6361 : real(RKC) :: rand(s1, s2)
6362 : type(rngf_type) , intent(inout) :: rng
6363 : end function
6364 :
6365 : #endif
6366 :
6367 : #if RK3_ENABLED
6368 : impure module function getUnifRandRNGFLU_D2_RK3(rng, lb, ub, s1, s2) result(rand)
6369 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6370 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_RK3
6371 : #endif
6372 : use pm_kind, only: RKC => RK3
6373 : real(RKC) , intent(in) :: lb, ub
6374 : integer(IK) , intent(in) :: s1, s2
6375 : real(RKC) :: rand(s1, s2)
6376 : type(rngf_type) , intent(inout) :: rng
6377 : end function
6378 :
6379 : #endif
6380 :
6381 : #if RK2_ENABLED
6382 : impure module function getUnifRandRNGFLU_D2_RK2(rng, lb, ub, s1, s2) result(rand)
6383 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6384 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_RK2
6385 : #endif
6386 : use pm_kind, only: RKC => RK2
6387 : real(RKC) , intent(in) :: lb, ub
6388 : integer(IK) , intent(in) :: s1, s2
6389 : real(RKC) :: rand(s1, s2)
6390 : type(rngf_type) , intent(inout) :: rng
6391 : end function
6392 : #endif
6393 :
6394 : #if RK1_ENABLED
6395 : impure module function getUnifRandRNGFLU_D2_RK1(rng, lb, ub, s1, s2) result(rand)
6396 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6397 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D2_RK1
6398 : #endif
6399 : use pm_kind, only: RKC => RK1
6400 : real(RKC) , intent(in) :: lb, ub
6401 : integer(IK) , intent(in) :: s1, s2
6402 : real(RKC) :: rand(s1, s2)
6403 : type(rngf_type) , intent(inout) :: rng
6404 : end function
6405 : #endif
6406 :
6407 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6408 :
6409 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6410 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6411 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6412 :
6413 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6414 :
6415 : #if SK5_ENABLED
6416 : impure module function getUnifRandRNGFLU_D3_SK5(rng, lb, ub, s1, s2, s3) result(rand)
6417 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6418 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_SK5
6419 : #endif
6420 : use pm_kind, only: SKC => SK5
6421 : character(*,SKC) , intent(in) :: lb, ub
6422 : integer(IK) , intent(in) :: s1, s2, s3
6423 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
6424 : type(rngf_type) , intent(inout) :: rng
6425 : end function
6426 : #endif
6427 :
6428 : #if SK4_ENABLED
6429 : impure module function getUnifRandRNGFLU_D3_SK4(rng, lb, ub, s1, s2, s3) result(rand)
6430 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6431 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_SK4
6432 : #endif
6433 : use pm_kind, only: SKC => SK4
6434 : character(*,SKC) , intent(in) :: lb, ub
6435 : integer(IK) , intent(in) :: s1, s2, s3
6436 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
6437 : type(rngf_type) , intent(inout) :: rng
6438 : end function
6439 : #endif
6440 :
6441 : #if SK3_ENABLED
6442 : impure module function getUnifRandRNGFLU_D3_SK3(rng, lb, ub, s1, s2, s3) result(rand)
6443 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6444 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_SK3
6445 : #endif
6446 : use pm_kind, only: SKC => SK3
6447 : character(*,SKC) , intent(in) :: lb, ub
6448 : integer(IK) , intent(in) :: s1, s2, s3
6449 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
6450 : type(rngf_type) , intent(inout) :: rng
6451 : end function
6452 : #endif
6453 :
6454 : #if SK2_ENABLED
6455 : impure module function getUnifRandRNGFLU_D3_SK2(rng, lb, ub, s1, s2, s3) result(rand)
6456 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6457 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_SK2
6458 : #endif
6459 : use pm_kind, only: SKC => SK2
6460 : character(*,SKC) , intent(in) :: lb, ub
6461 : integer(IK) , intent(in) :: s1, s2, s3
6462 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
6463 : type(rngf_type) , intent(inout) :: rng
6464 : end function
6465 : #endif
6466 :
6467 : #if SK1_ENABLED
6468 : impure module function getUnifRandRNGFLU_D3_SK1(rng, lb, ub, s1, s2, s3) result(rand)
6469 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6470 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_SK1
6471 : #endif
6472 : use pm_kind, only: SKC => SK1
6473 : character(*,SKC) , intent(in) :: lb, ub
6474 : integer(IK) , intent(in) :: s1, s2, s3
6475 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
6476 : type(rngf_type) , intent(inout) :: rng
6477 : end function
6478 : #endif
6479 :
6480 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6481 :
6482 : #if IK5_ENABLED
6483 : impure module function getUnifRandRNGFLU_D3_IK5(rng, lb, ub, s1, s2, s3) result(rand)
6484 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6485 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_IK5
6486 : #endif
6487 : use pm_kind, only: IKC => IK5
6488 : integer(IKC) , intent(in) :: lb, ub
6489 : integer(IK) , intent(in) :: s1, s2, s3
6490 : integer(IKC) :: rand(s1, s2, s3)
6491 : type(rngf_type) , intent(inout) :: rng
6492 : end function
6493 : #endif
6494 :
6495 : #if IK4_ENABLED
6496 : impure module function getUnifRandRNGFLU_D3_IK4(rng, lb, ub, s1, s2, s3) result(rand)
6497 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6498 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_IK4
6499 : #endif
6500 : use pm_kind, only: IKC => IK4
6501 : integer(IKC) , intent(in) :: lb, ub
6502 : integer(IK) , intent(in) :: s1, s2, s3
6503 : integer(IKC) :: rand(s1, s2, s3)
6504 : type(rngf_type) , intent(inout) :: rng
6505 : end function
6506 : #endif
6507 :
6508 : #if IK3_ENABLED
6509 : impure module function getUnifRandRNGFLU_D3_IK3(rng, lb, ub, s1, s2, s3) result(rand)
6510 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6511 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_IK3
6512 : #endif
6513 : use pm_kind, only: IKC => IK3
6514 : integer(IKC) , intent(in) :: lb, ub
6515 : integer(IK) , intent(in) :: s1, s2, s3
6516 : integer(IKC) :: rand(s1, s2, s3)
6517 : type(rngf_type) , intent(inout) :: rng
6518 : end function
6519 : #endif
6520 :
6521 : #if IK2_ENABLED
6522 : impure module function getUnifRandRNGFLU_D3_IK2(rng, lb, ub, s1, s2, s3) result(rand)
6523 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6524 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_IK2
6525 : #endif
6526 : use pm_kind, only: IKC => IK2
6527 : integer(IKC) , intent(in) :: lb, ub
6528 : integer(IK) , intent(in) :: s1, s2, s3
6529 : integer(IKC) :: rand(s1, s2, s3)
6530 : type(rngf_type) , intent(inout) :: rng
6531 : end function
6532 : #endif
6533 :
6534 : #if IK1_ENABLED
6535 : impure module function getUnifRandRNGFLU_D3_IK1(rng, lb, ub, s1, s2, s3) result(rand)
6536 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6537 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_IK1
6538 : #endif
6539 : use pm_kind, only: IKC => IK1
6540 : integer(IKC) , intent(in) :: lb, ub
6541 : integer(IK) , intent(in) :: s1, s2, s3
6542 : integer(IKC) :: rand(s1, s2, s3)
6543 : type(rngf_type) , intent(inout) :: rng
6544 : end function
6545 : #endif
6546 :
6547 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6548 :
6549 : #if LK5_ENABLED
6550 : impure module function getUnifRandRNGFLU_D3_LK5(rng, lb, ub, s1, s2, s3) result(rand)
6551 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6552 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_LK5
6553 : #endif
6554 : use pm_kind, only: LKC => LK5
6555 : logical(LKC) , intent(in) :: lb, ub
6556 : integer(IK) , intent(in) :: s1, s2, s3
6557 : logical(LKC) :: rand(s1, s2, s3)
6558 : type(rngf_type) , intent(inout) :: rng
6559 : end function
6560 : #endif
6561 :
6562 : #if LK4_ENABLED
6563 : impure module function getUnifRandRNGFLU_D3_LK4(rng, lb, ub, s1, s2, s3) result(rand)
6564 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6565 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_LK4
6566 : #endif
6567 : use pm_kind, only: LKC => LK4
6568 : logical(LKC) , intent(in) :: lb, ub
6569 : integer(IK) , intent(in) :: s1, s2, s3
6570 : logical(LKC) :: rand(s1, s2, s3)
6571 : type(rngf_type) , intent(inout) :: rng
6572 : end function
6573 : #endif
6574 :
6575 : #if LK3_ENABLED
6576 : impure module function getUnifRandRNGFLU_D3_LK3(rng, lb, ub, s1, s2, s3) result(rand)
6577 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6578 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_LK3
6579 : #endif
6580 : use pm_kind, only: LKC => LK3
6581 : logical(LKC) , intent(in) :: lb, ub
6582 : integer(IK) , intent(in) :: s1, s2, s3
6583 : logical(LKC) :: rand(s1, s2, s3)
6584 : type(rngf_type) , intent(inout) :: rng
6585 : end function
6586 : #endif
6587 :
6588 : #if LK2_ENABLED
6589 : impure module function getUnifRandRNGFLU_D3_LK2(rng, lb, ub, s1, s2, s3) result(rand)
6590 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6591 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_LK2
6592 : #endif
6593 : use pm_kind, only: LKC => LK2
6594 : logical(LKC) , intent(in) :: lb, ub
6595 : integer(IK) , intent(in) :: s1, s2, s3
6596 : logical(LKC) :: rand(s1, s2, s3)
6597 : type(rngf_type) , intent(inout) :: rng
6598 : end function
6599 : #endif
6600 :
6601 : #if LK1_ENABLED
6602 : impure module function getUnifRandRNGFLU_D3_LK1(rng, lb, ub, s1, s2, s3) result(rand)
6603 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6604 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_LK1
6605 : #endif
6606 : use pm_kind, only: LKC => LK1
6607 : logical(LKC) , intent(in) :: lb, ub
6608 : integer(IK) , intent(in) :: s1, s2, s3
6609 : logical(LKC) :: rand(s1, s2, s3)
6610 : type(rngf_type) , intent(inout) :: rng
6611 : end function
6612 : #endif
6613 :
6614 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6615 :
6616 : #if CK5_ENABLED
6617 : impure module function getUnifRandRNGFLU_D3_CK5(rng, lb, ub, s1, s2, s3) result(rand)
6618 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6619 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_CK5
6620 : #endif
6621 : use pm_kind, only: CKC => CK5
6622 : complex(CKC) , intent(in) :: lb, ub
6623 : integer(IK) , intent(in) :: s1, s2, s3
6624 : complex(CKC) :: rand(s1, s2, s3)
6625 : type(rngf_type) , intent(inout) :: rng
6626 : end function
6627 : #endif
6628 :
6629 : #if CK4_ENABLED
6630 : impure module function getUnifRandRNGFLU_D3_CK4(rng, lb, ub, s1, s2, s3) result(rand)
6631 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6632 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_CK4
6633 : #endif
6634 : use pm_kind, only: CKC => CK4
6635 : complex(CKC) , intent(in) :: lb, ub
6636 : integer(IK) , intent(in) :: s1, s2, s3
6637 : complex(CKC) :: rand(s1, s2, s3)
6638 : type(rngf_type) , intent(inout) :: rng
6639 : end function
6640 : #endif
6641 :
6642 : #if CK3_ENABLED
6643 : impure module function getUnifRandRNGFLU_D3_CK3(rng, lb, ub, s1, s2, s3) result(rand)
6644 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6645 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_CK3
6646 : #endif
6647 : use pm_kind, only: CKC => CK3
6648 : complex(CKC) , intent(in) :: lb, ub
6649 : integer(IK) , intent(in) :: s1, s2, s3
6650 : complex(CKC) :: rand(s1, s2, s3)
6651 : type(rngf_type) , intent(inout) :: rng
6652 : end function
6653 : #endif
6654 :
6655 : #if CK2_ENABLED
6656 : impure module function getUnifRandRNGFLU_D3_CK2(rng, lb, ub, s1, s2, s3) result(rand)
6657 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6658 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_CK2
6659 : #endif
6660 : use pm_kind, only: CKC => CK2
6661 : complex(CKC) , intent(in) :: lb, ub
6662 : integer(IK) , intent(in) :: s1, s2, s3
6663 : complex(CKC) :: rand(s1, s2, s3)
6664 : type(rngf_type) , intent(inout) :: rng
6665 : end function
6666 : #endif
6667 :
6668 : #if CK1_ENABLED
6669 : impure module function getUnifRandRNGFLU_D3_CK1(rng, lb, ub, s1, s2, s3) result(rand)
6670 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6671 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_CK1
6672 : #endif
6673 : use pm_kind, only: CKC => CK1
6674 : complex(CKC) , intent(in) :: lb, ub
6675 : integer(IK) , intent(in) :: s1, s2, s3
6676 : complex(CKC) :: rand(s1, s2, s3)
6677 : type(rngf_type) , intent(inout) :: rng
6678 : end function
6679 : #endif
6680 :
6681 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6682 :
6683 : #if RK5_ENABLED
6684 : impure module function getUnifRandRNGFLU_D3_RK5(rng, lb, ub, s1, s2, s3) result(rand)
6685 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6686 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_RK5
6687 : #endif
6688 : use pm_kind, only: RKC => RK5
6689 : real(RKC) , intent(in) :: lb, ub
6690 : integer(IK) , intent(in) :: s1, s2, s3
6691 : real(RKC) :: rand(s1, s2, s3)
6692 : type(rngf_type) , intent(inout) :: rng
6693 : end function
6694 :
6695 : #endif
6696 :
6697 : #if RK4_ENABLED
6698 : impure module function getUnifRandRNGFLU_D3_RK4(rng, lb, ub, s1, s2, s3) result(rand)
6699 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6700 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_RK4
6701 : #endif
6702 : use pm_kind, only: RKC => RK4
6703 : real(RKC) , intent(in) :: lb, ub
6704 : integer(IK) , intent(in) :: s1, s2, s3
6705 : real(RKC) :: rand(s1, s2, s3)
6706 : type(rngf_type) , intent(inout) :: rng
6707 : end function
6708 :
6709 : #endif
6710 :
6711 : #if RK3_ENABLED
6712 : impure module function getUnifRandRNGFLU_D3_RK3(rng, lb, ub, s1, s2, s3) result(rand)
6713 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6714 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_RK3
6715 : #endif
6716 : use pm_kind, only: RKC => RK3
6717 : real(RKC) , intent(in) :: lb, ub
6718 : integer(IK) , intent(in) :: s1, s2, s3
6719 : real(RKC) :: rand(s1, s2, s3)
6720 : type(rngf_type) , intent(inout) :: rng
6721 : end function
6722 :
6723 : #endif
6724 :
6725 : #if RK2_ENABLED
6726 : impure module function getUnifRandRNGFLU_D3_RK2(rng, lb, ub, s1, s2, s3) result(rand)
6727 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6728 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_RK2
6729 : #endif
6730 : use pm_kind, only: RKC => RK2
6731 : real(RKC) , intent(in) :: lb, ub
6732 : integer(IK) , intent(in) :: s1, s2, s3
6733 : real(RKC) :: rand(s1, s2, s3)
6734 : type(rngf_type) , intent(inout) :: rng
6735 : end function
6736 : #endif
6737 :
6738 : #if RK1_ENABLED
6739 : impure module function getUnifRandRNGFLU_D3_RK1(rng, lb, ub, s1, s2, s3) result(rand)
6740 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6741 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGFLU_D3_RK1
6742 : #endif
6743 : use pm_kind, only: RKC => RK1
6744 : real(RKC) , intent(in) :: lb, ub
6745 : integer(IK) , intent(in) :: s1, s2, s3
6746 : real(RKC) :: rand(s1, s2, s3)
6747 : type(rngf_type) , intent(inout) :: rng
6748 : end function
6749 : #endif
6750 :
6751 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6752 :
6753 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6754 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6755 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6756 :
6757 : end interface
6758 :
6759 : ! RNGS
6760 :
6761 : interface getUnifRand
6762 :
6763 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6764 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6765 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6766 :
6767 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6768 :
6769 : impure module function getUnifRandRNGSDD_D0_LK(rng) result(rand)
6770 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6771 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSDD_D0_LK
6772 : #endif
6773 : use pm_kind, only: LKC => LK
6774 : logical(LKC) :: rand
6775 : type(splitmix64_type) , intent(inout) :: rng
6776 : end function
6777 :
6778 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6779 :
6780 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6781 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6782 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6783 :
6784 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6785 :
6786 : #if SK5_ENABLED
6787 : impure elemental module function getUnifRandRNGSLU_D0_SK5(rng, lb, ub) result(rand)
6788 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6789 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_SK5
6790 : #endif
6791 : use pm_kind, only: SKC => SK5
6792 : character(*,SKC) , intent(in) :: lb, ub
6793 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
6794 : type(splitmix64_type) , intent(inout) :: rng
6795 : end function
6796 : #endif
6797 :
6798 : #if SK4_ENABLED
6799 : impure elemental module function getUnifRandRNGSLU_D0_SK4(rng, lb, ub) result(rand)
6800 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6801 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_SK4
6802 : #endif
6803 : use pm_kind, only: SKC => SK4
6804 : character(*,SKC) , intent(in) :: lb, ub
6805 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
6806 : type(splitmix64_type) , intent(inout) :: rng
6807 : end function
6808 : #endif
6809 :
6810 : #if SK3_ENABLED
6811 : impure elemental module function getUnifRandRNGSLU_D0_SK3(rng, lb, ub) result(rand)
6812 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6813 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_SK3
6814 : #endif
6815 : use pm_kind, only: SKC => SK3
6816 : character(*,SKC) , intent(in) :: lb, ub
6817 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
6818 : type(splitmix64_type) , intent(inout) :: rng
6819 : end function
6820 : #endif
6821 :
6822 : #if SK2_ENABLED
6823 : impure elemental module function getUnifRandRNGSLU_D0_SK2(rng, lb, ub) result(rand)
6824 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6825 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_SK2
6826 : #endif
6827 : use pm_kind, only: SKC => SK2
6828 : character(*,SKC) , intent(in) :: lb, ub
6829 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
6830 : type(splitmix64_type) , intent(inout) :: rng
6831 : end function
6832 : #endif
6833 :
6834 : #if SK1_ENABLED
6835 : impure elemental module function getUnifRandRNGSLU_D0_SK1(rng, lb, ub) result(rand)
6836 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6837 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_SK1
6838 : #endif
6839 : use pm_kind, only: SKC => SK1
6840 : character(*,SKC) , intent(in) :: lb, ub
6841 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
6842 : type(splitmix64_type) , intent(inout) :: rng
6843 : end function
6844 : #endif
6845 :
6846 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6847 :
6848 : #if IK5_ENABLED
6849 : impure elemental module function getUnifRandRNGSLU_D0_IK5(rng, lb, ub) result(rand)
6850 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6851 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_IK5
6852 : #endif
6853 : use pm_kind, only: IKC => IK5
6854 : integer(IKC) , intent(in) :: lb, ub
6855 : integer(IKC) :: rand
6856 : type(splitmix64_type) , intent(inout) :: rng
6857 : end function
6858 : #endif
6859 :
6860 : #if IK4_ENABLED
6861 : impure elemental module function getUnifRandRNGSLU_D0_IK4(rng, lb, ub) result(rand)
6862 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6863 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_IK4
6864 : #endif
6865 : use pm_kind, only: IKC => IK4
6866 : integer(IKC) , intent(in) :: lb, ub
6867 : integer(IKC) :: rand
6868 : type(splitmix64_type) , intent(inout) :: rng
6869 : end function
6870 : #endif
6871 :
6872 : #if IK3_ENABLED
6873 : impure elemental module function getUnifRandRNGSLU_D0_IK3(rng, lb, ub) result(rand)
6874 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6875 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_IK3
6876 : #endif
6877 : use pm_kind, only: IKC => IK3
6878 : integer(IKC) , intent(in) :: lb, ub
6879 : integer(IKC) :: rand
6880 : type(splitmix64_type) , intent(inout) :: rng
6881 : end function
6882 : #endif
6883 :
6884 : #if IK2_ENABLED
6885 : impure elemental module function getUnifRandRNGSLU_D0_IK2(rng, lb, ub) result(rand)
6886 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6887 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_IK2
6888 : #endif
6889 : use pm_kind, only: IKC => IK2
6890 : integer(IKC) , intent(in) :: lb, ub
6891 : integer(IKC) :: rand
6892 : type(splitmix64_type) , intent(inout) :: rng
6893 : end function
6894 : #endif
6895 :
6896 : #if IK1_ENABLED
6897 : impure elemental module function getUnifRandRNGSLU_D0_IK1(rng, lb, ub) result(rand)
6898 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6899 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_IK1
6900 : #endif
6901 : use pm_kind, only: IKC => IK1
6902 : integer(IKC) , intent(in) :: lb, ub
6903 : integer(IKC) :: rand
6904 : type(splitmix64_type) , intent(inout) :: rng
6905 : end function
6906 : #endif
6907 :
6908 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6909 :
6910 : #if LK5_ENABLED
6911 : impure elemental module function getUnifRandRNGSLU_D0_LK5(rng, lb, ub) result(rand)
6912 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6913 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_LK5
6914 : #endif
6915 : use pm_kind, only: LKC => LK5
6916 : logical(LKC) , intent(in) :: lb, ub
6917 : logical(LKC) :: rand
6918 : type(splitmix64_type) , intent(inout) :: rng
6919 : end function
6920 : #endif
6921 :
6922 : #if LK4_ENABLED
6923 : impure elemental module function getUnifRandRNGSLU_D0_LK4(rng, lb, ub) result(rand)
6924 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6925 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_LK4
6926 : #endif
6927 : use pm_kind, only: LKC => LK4
6928 : logical(LKC) , intent(in) :: lb, ub
6929 : logical(LKC) :: rand
6930 : type(splitmix64_type) , intent(inout) :: rng
6931 : end function
6932 : #endif
6933 :
6934 : #if LK3_ENABLED
6935 : impure elemental module function getUnifRandRNGSLU_D0_LK3(rng, lb, ub) result(rand)
6936 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6937 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_LK3
6938 : #endif
6939 : use pm_kind, only: LKC => LK3
6940 : logical(LKC) , intent(in) :: lb, ub
6941 : logical(LKC) :: rand
6942 : type(splitmix64_type) , intent(inout) :: rng
6943 : end function
6944 : #endif
6945 :
6946 : #if LK2_ENABLED
6947 : impure elemental module function getUnifRandRNGSLU_D0_LK2(rng, lb, ub) result(rand)
6948 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6949 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_LK2
6950 : #endif
6951 : use pm_kind, only: LKC => LK2
6952 : logical(LKC) , intent(in) :: lb, ub
6953 : logical(LKC) :: rand
6954 : type(splitmix64_type) , intent(inout) :: rng
6955 : end function
6956 : #endif
6957 :
6958 : #if LK1_ENABLED
6959 : impure elemental module function getUnifRandRNGSLU_D0_LK1(rng, lb, ub) result(rand)
6960 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6961 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_LK1
6962 : #endif
6963 : use pm_kind, only: LKC => LK1
6964 : logical(LKC) , intent(in) :: lb, ub
6965 : logical(LKC) :: rand
6966 : type(splitmix64_type) , intent(inout) :: rng
6967 : end function
6968 : #endif
6969 :
6970 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6971 :
6972 : #if CK5_ENABLED
6973 : impure elemental module function getUnifRandRNGSLU_D0_CK5(rng, lb, ub) result(rand)
6974 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6975 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_CK5
6976 : #endif
6977 : use pm_kind, only: CKC => CK5
6978 : complex(CKC) , intent(in) :: lb, ub
6979 : complex(CKC) :: rand
6980 : type(splitmix64_type) , intent(inout) :: rng
6981 : end function
6982 : #endif
6983 :
6984 : #if CK4_ENABLED
6985 : impure elemental module function getUnifRandRNGSLU_D0_CK4(rng, lb, ub) result(rand)
6986 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6987 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_CK4
6988 : #endif
6989 : use pm_kind, only: CKC => CK4
6990 : complex(CKC) , intent(in) :: lb, ub
6991 : complex(CKC) :: rand
6992 : type(splitmix64_type) , intent(inout) :: rng
6993 : end function
6994 : #endif
6995 :
6996 : #if CK3_ENABLED
6997 : impure elemental module function getUnifRandRNGSLU_D0_CK3(rng, lb, ub) result(rand)
6998 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6999 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_CK3
7000 : #endif
7001 : use pm_kind, only: CKC => CK3
7002 : complex(CKC) , intent(in) :: lb, ub
7003 : complex(CKC) :: rand
7004 : type(splitmix64_type) , intent(inout) :: rng
7005 : end function
7006 : #endif
7007 :
7008 : #if CK2_ENABLED
7009 : impure elemental module function getUnifRandRNGSLU_D0_CK2(rng, lb, ub) result(rand)
7010 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7011 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_CK2
7012 : #endif
7013 : use pm_kind, only: CKC => CK2
7014 : complex(CKC) , intent(in) :: lb, ub
7015 : complex(CKC) :: rand
7016 : type(splitmix64_type) , intent(inout) :: rng
7017 : end function
7018 : #endif
7019 :
7020 : #if CK1_ENABLED
7021 : impure elemental module function getUnifRandRNGSLU_D0_CK1(rng, lb, ub) result(rand)
7022 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7023 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_CK1
7024 : #endif
7025 : use pm_kind, only: CKC => CK1
7026 : complex(CKC) , intent(in) :: lb, ub
7027 : complex(CKC) :: rand
7028 : type(splitmix64_type) , intent(inout) :: rng
7029 : end function
7030 : #endif
7031 :
7032 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7033 :
7034 : #if RK5_ENABLED
7035 : impure elemental module function getUnifRandRNGSLU_D0_RK5(rng, lb, ub) result(rand)
7036 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7037 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_RK5
7038 : #endif
7039 : use pm_kind, only: RKC => RK5
7040 : real(RKC) , intent(in) :: lb, ub
7041 : real(RKC) :: rand
7042 : type(splitmix64_type) , intent(inout) :: rng
7043 : end function
7044 : #endif
7045 :
7046 : #if RK4_ENABLED
7047 : impure elemental module function getUnifRandRNGSLU_D0_RK4(rng, lb, ub) result(rand)
7048 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7049 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_RK4
7050 : #endif
7051 : use pm_kind, only: RKC => RK4
7052 : real(RKC) , intent(in) :: lb, ub
7053 : real(RKC) :: rand
7054 : type(splitmix64_type) , intent(inout) :: rng
7055 : end function
7056 : #endif
7057 :
7058 : #if RK3_ENABLED
7059 : impure elemental module function getUnifRandRNGSLU_D0_RK3(rng, lb, ub) result(rand)
7060 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7061 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_RK3
7062 : #endif
7063 : use pm_kind, only: RKC => RK3
7064 : real(RKC) , intent(in) :: lb, ub
7065 : real(RKC) :: rand
7066 : type(splitmix64_type) , intent(inout) :: rng
7067 : end function
7068 : #endif
7069 :
7070 : #if RK2_ENABLED
7071 : impure elemental module function getUnifRandRNGSLU_D0_RK2(rng, lb, ub) result(rand)
7072 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7073 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_RK2
7074 : #endif
7075 : use pm_kind, only: RKC => RK2
7076 : real(RKC) , intent(in) :: lb, ub
7077 : real(RKC) :: rand
7078 : type(splitmix64_type) , intent(inout) :: rng
7079 : end function
7080 : #endif
7081 :
7082 : #if RK1_ENABLED
7083 : impure elemental module function getUnifRandRNGSLU_D0_RK1(rng, lb, ub) result(rand)
7084 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7085 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D0_RK1
7086 : #endif
7087 : use pm_kind, only: RKC => RK1
7088 : real(RKC) , intent(in) :: lb, ub
7089 : real(RKC) :: rand
7090 : type(splitmix64_type) , intent(inout) :: rng
7091 : end function
7092 : #endif
7093 :
7094 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7095 :
7096 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7097 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7098 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7099 :
7100 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7101 :
7102 : #if SK5_ENABLED
7103 : impure module function getUnifRandRNGSLU_D1_SK5(rng, lb, ub, s1) result(rand)
7104 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7105 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_SK5
7106 : #endif
7107 : use pm_kind, only: SKC => SK5
7108 : character(*,SKC) , intent(in) :: lb, ub
7109 : integer(IK) , intent(in) :: s1
7110 : character(len(lb,IK),SKC) :: rand(s1)
7111 : type(splitmix64_type) , intent(inout) :: rng
7112 : end function
7113 : #endif
7114 :
7115 : #if SK4_ENABLED
7116 : impure module function getUnifRandRNGSLU_D1_SK4(rng, lb, ub, s1) result(rand)
7117 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7118 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_SK4
7119 : #endif
7120 : use pm_kind, only: SKC => SK4
7121 : character(*,SKC) , intent(in) :: lb, ub
7122 : integer(IK) , intent(in) :: s1
7123 : character(len(lb,IK),SKC) :: rand(s1)
7124 : type(splitmix64_type) , intent(inout) :: rng
7125 : end function
7126 : #endif
7127 :
7128 : #if SK3_ENABLED
7129 : impure module function getUnifRandRNGSLU_D1_SK3(rng, lb, ub, s1) result(rand)
7130 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7131 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_SK3
7132 : #endif
7133 : use pm_kind, only: SKC => SK3
7134 : character(*,SKC) , intent(in) :: lb, ub
7135 : integer(IK) , intent(in) :: s1
7136 : character(len(lb,IK),SKC) :: rand(s1)
7137 : type(splitmix64_type) , intent(inout) :: rng
7138 : end function
7139 : #endif
7140 :
7141 : #if SK2_ENABLED
7142 : impure module function getUnifRandRNGSLU_D1_SK2(rng, lb, ub, s1) result(rand)
7143 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7144 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_SK2
7145 : #endif
7146 : use pm_kind, only: SKC => SK2
7147 : character(*,SKC) , intent(in) :: lb, ub
7148 : integer(IK) , intent(in) :: s1
7149 : character(len(lb,IK),SKC) :: rand(s1)
7150 : type(splitmix64_type) , intent(inout) :: rng
7151 : end function
7152 : #endif
7153 :
7154 : #if SK1_ENABLED
7155 : impure module function getUnifRandRNGSLU_D1_SK1(rng, lb, ub, s1) result(rand)
7156 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7157 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_SK1
7158 : #endif
7159 : use pm_kind, only: SKC => SK1
7160 : character(*,SKC) , intent(in) :: lb, ub
7161 : integer(IK) , intent(in) :: s1
7162 : character(len(lb,IK),SKC) :: rand(s1)
7163 : type(splitmix64_type) , intent(inout) :: rng
7164 : end function
7165 : #endif
7166 :
7167 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7168 :
7169 : #if IK5_ENABLED
7170 : impure module function getUnifRandRNGSLU_D1_IK5(rng, lb, ub, s1) result(rand)
7171 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7172 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_IK5
7173 : #endif
7174 : use pm_kind, only: IKC => IK5
7175 : integer(IKC) , intent(in) :: lb, ub
7176 : integer(IK) , intent(in) :: s1
7177 : integer(IKC) :: rand(s1)
7178 : type(splitmix64_type) , intent(inout) :: rng
7179 : end function
7180 : #endif
7181 :
7182 : #if IK4_ENABLED
7183 : impure module function getUnifRandRNGSLU_D1_IK4(rng, lb, ub, s1) result(rand)
7184 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7185 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_IK4
7186 : #endif
7187 : use pm_kind, only: IKC => IK4
7188 : integer(IKC) , intent(in) :: lb, ub
7189 : integer(IK) , intent(in) :: s1
7190 : integer(IKC) :: rand(s1)
7191 : type(splitmix64_type) , intent(inout) :: rng
7192 : end function
7193 : #endif
7194 :
7195 : #if IK3_ENABLED
7196 : impure module function getUnifRandRNGSLU_D1_IK3(rng, lb, ub, s1) result(rand)
7197 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7198 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_IK3
7199 : #endif
7200 : use pm_kind, only: IKC => IK3
7201 : integer(IKC) , intent(in) :: lb, ub
7202 : integer(IK) , intent(in) :: s1
7203 : integer(IKC) :: rand(s1)
7204 : type(splitmix64_type) , intent(inout) :: rng
7205 : end function
7206 : #endif
7207 :
7208 : #if IK2_ENABLED
7209 : impure module function getUnifRandRNGSLU_D1_IK2(rng, lb, ub, s1) result(rand)
7210 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7211 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_IK2
7212 : #endif
7213 : use pm_kind, only: IKC => IK2
7214 : integer(IKC) , intent(in) :: lb, ub
7215 : integer(IK) , intent(in) :: s1
7216 : integer(IKC) :: rand(s1)
7217 : type(splitmix64_type) , intent(inout) :: rng
7218 : end function
7219 : #endif
7220 :
7221 : #if IK1_ENABLED
7222 : impure module function getUnifRandRNGSLU_D1_IK1(rng, lb, ub, s1) result(rand)
7223 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7224 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_IK1
7225 : #endif
7226 : use pm_kind, only: IKC => IK1
7227 : integer(IKC) , intent(in) :: lb, ub
7228 : integer(IK) , intent(in) :: s1
7229 : integer(IKC) :: rand(s1)
7230 : type(splitmix64_type) , intent(inout) :: rng
7231 : end function
7232 : #endif
7233 :
7234 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7235 :
7236 : #if LK5_ENABLED
7237 : impure module function getUnifRandRNGSLU_D1_LK5(rng, lb, ub, s1) result(rand)
7238 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7239 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_LK5
7240 : #endif
7241 : use pm_kind, only: LKC => LK5
7242 : logical(LKC) , intent(in) :: lb, ub
7243 : integer(IK) , intent(in) :: s1
7244 : logical(LKC) :: rand(s1)
7245 : type(splitmix64_type) , intent(inout) :: rng
7246 : end function
7247 : #endif
7248 :
7249 : #if LK4_ENABLED
7250 : impure module function getUnifRandRNGSLU_D1_LK4(rng, lb, ub, s1) result(rand)
7251 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7252 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_LK4
7253 : #endif
7254 : use pm_kind, only: LKC => LK4
7255 : logical(LKC) , intent(in) :: lb, ub
7256 : integer(IK) , intent(in) :: s1
7257 : logical(LKC) :: rand(s1)
7258 : type(splitmix64_type) , intent(inout) :: rng
7259 : end function
7260 : #endif
7261 :
7262 : #if LK3_ENABLED
7263 : impure module function getUnifRandRNGSLU_D1_LK3(rng, lb, ub, s1) result(rand)
7264 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7265 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_LK3
7266 : #endif
7267 : use pm_kind, only: LKC => LK3
7268 : logical(LKC) , intent(in) :: lb, ub
7269 : integer(IK) , intent(in) :: s1
7270 : logical(LKC) :: rand(s1)
7271 : type(splitmix64_type) , intent(inout) :: rng
7272 : end function
7273 : #endif
7274 :
7275 : #if LK2_ENABLED
7276 : impure module function getUnifRandRNGSLU_D1_LK2(rng, lb, ub, s1) result(rand)
7277 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7278 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_LK2
7279 : #endif
7280 : use pm_kind, only: LKC => LK2
7281 : logical(LKC) , intent(in) :: lb, ub
7282 : integer(IK) , intent(in) :: s1
7283 : logical(LKC) :: rand(s1)
7284 : type(splitmix64_type) , intent(inout) :: rng
7285 : end function
7286 : #endif
7287 :
7288 : #if LK1_ENABLED
7289 : impure module function getUnifRandRNGSLU_D1_LK1(rng, lb, ub, s1) result(rand)
7290 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7291 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_LK1
7292 : #endif
7293 : use pm_kind, only: LKC => LK1
7294 : logical(LKC) , intent(in) :: lb, ub
7295 : integer(IK) , intent(in) :: s1
7296 : logical(LKC) :: rand(s1)
7297 : type(splitmix64_type) , intent(inout) :: rng
7298 : end function
7299 : #endif
7300 :
7301 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7302 :
7303 : #if CK5_ENABLED
7304 : impure module function getUnifRandRNGSLU_D1_CK5(rng, lb, ub, s1) result(rand)
7305 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7306 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_CK5
7307 : #endif
7308 : use pm_kind, only: CKC => CK5
7309 : complex(CKC) , intent(in) :: lb, ub
7310 : integer(IK) , intent(in) :: s1
7311 : complex(CKC) :: rand(s1)
7312 : type(splitmix64_type) , intent(inout) :: rng
7313 : end function
7314 : #endif
7315 :
7316 : #if CK4_ENABLED
7317 : impure module function getUnifRandRNGSLU_D1_CK4(rng, lb, ub, s1) result(rand)
7318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7319 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_CK4
7320 : #endif
7321 : use pm_kind, only: CKC => CK4
7322 : complex(CKC) , intent(in) :: lb, ub
7323 : integer(IK) , intent(in) :: s1
7324 : complex(CKC) :: rand(s1)
7325 : type(splitmix64_type) , intent(inout) :: rng
7326 : end function
7327 : #endif
7328 :
7329 : #if CK3_ENABLED
7330 : impure module function getUnifRandRNGSLU_D1_CK3(rng, lb, ub, s1) result(rand)
7331 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7332 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_CK3
7333 : #endif
7334 : use pm_kind, only: CKC => CK3
7335 : complex(CKC) , intent(in) :: lb, ub
7336 : integer(IK) , intent(in) :: s1
7337 : complex(CKC) :: rand(s1)
7338 : type(splitmix64_type) , intent(inout) :: rng
7339 : end function
7340 : #endif
7341 :
7342 : #if CK2_ENABLED
7343 : impure module function getUnifRandRNGSLU_D1_CK2(rng, lb, ub, s1) result(rand)
7344 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7345 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_CK2
7346 : #endif
7347 : use pm_kind, only: CKC => CK2
7348 : complex(CKC) , intent(in) :: lb, ub
7349 : integer(IK) , intent(in) :: s1
7350 : complex(CKC) :: rand(s1)
7351 : type(splitmix64_type) , intent(inout) :: rng
7352 : end function
7353 : #endif
7354 :
7355 : #if CK1_ENABLED
7356 : impure module function getUnifRandRNGSLU_D1_CK1(rng, lb, ub, s1) result(rand)
7357 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7358 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_CK1
7359 : #endif
7360 : use pm_kind, only: CKC => CK1
7361 : complex(CKC) , intent(in) :: lb, ub
7362 : integer(IK) , intent(in) :: s1
7363 : complex(CKC) :: rand(s1)
7364 : type(splitmix64_type) , intent(inout) :: rng
7365 : end function
7366 : #endif
7367 :
7368 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7369 :
7370 : #if RK5_ENABLED
7371 : impure module function getUnifRandRNGSLU_D1_RK5(rng, lb, ub, s1) result(rand)
7372 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7373 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_RK5
7374 : #endif
7375 : use pm_kind, only: RKC => RK5
7376 : real(RKC) , intent(in) :: lb, ub
7377 : integer(IK) , intent(in) :: s1
7378 : real(RKC) :: rand(s1)
7379 : type(splitmix64_type) , intent(inout) :: rng
7380 : end function
7381 :
7382 : #endif
7383 :
7384 : #if RK4_ENABLED
7385 : impure module function getUnifRandRNGSLU_D1_RK4(rng, lb, ub, s1) result(rand)
7386 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7387 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_RK4
7388 : #endif
7389 : use pm_kind, only: RKC => RK4
7390 : real(RKC) , intent(in) :: lb, ub
7391 : integer(IK) , intent(in) :: s1
7392 : real(RKC) :: rand(s1)
7393 : type(splitmix64_type) , intent(inout) :: rng
7394 : end function
7395 :
7396 : #endif
7397 :
7398 : #if RK3_ENABLED
7399 : impure module function getUnifRandRNGSLU_D1_RK3(rng, lb, ub, s1) result(rand)
7400 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7401 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_RK3
7402 : #endif
7403 : use pm_kind, only: RKC => RK3
7404 : real(RKC) , intent(in) :: lb, ub
7405 : integer(IK) , intent(in) :: s1
7406 : real(RKC) :: rand(s1)
7407 : type(splitmix64_type) , intent(inout) :: rng
7408 : end function
7409 :
7410 : #endif
7411 :
7412 : #if RK2_ENABLED
7413 : impure module function getUnifRandRNGSLU_D1_RK2(rng, lb, ub, s1) result(rand)
7414 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7415 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_RK2
7416 : #endif
7417 : use pm_kind, only: RKC => RK2
7418 : real(RKC) , intent(in) :: lb, ub
7419 : integer(IK) , intent(in) :: s1
7420 : real(RKC) :: rand(s1)
7421 : type(splitmix64_type) , intent(inout) :: rng
7422 : end function
7423 : #endif
7424 :
7425 : #if RK1_ENABLED
7426 : impure module function getUnifRandRNGSLU_D1_RK1(rng, lb, ub, s1) result(rand)
7427 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7428 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D1_RK1
7429 : #endif
7430 : use pm_kind, only: RKC => RK1
7431 : real(RKC) , intent(in) :: lb, ub
7432 : integer(IK) , intent(in) :: s1
7433 : real(RKC) :: rand(s1)
7434 : type(splitmix64_type) , intent(inout) :: rng
7435 : end function
7436 : #endif
7437 :
7438 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7439 :
7440 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7441 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7442 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7443 :
7444 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7445 :
7446 : #if SK5_ENABLED
7447 : impure module function getUnifRandRNGSLU_D2_SK5(rng, lb, ub, s1, s2) result(rand)
7448 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7449 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_SK5
7450 : #endif
7451 : use pm_kind, only: SKC => SK5
7452 : character(*,SKC) , intent(in) :: lb, ub
7453 : integer(IK) , intent(in) :: s1, s2
7454 : character(len(lb,IK),SKC) :: rand(s1, s2)
7455 : type(splitmix64_type) , intent(inout) :: rng
7456 : end function
7457 : #endif
7458 :
7459 : #if SK4_ENABLED
7460 : impure module function getUnifRandRNGSLU_D2_SK4(rng, lb, ub, s1, s2) result(rand)
7461 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7462 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_SK4
7463 : #endif
7464 : use pm_kind, only: SKC => SK4
7465 : character(*,SKC) , intent(in) :: lb, ub
7466 : integer(IK) , intent(in) :: s1, s2
7467 : character(len(lb,IK),SKC) :: rand(s1, s2)
7468 : type(splitmix64_type) , intent(inout) :: rng
7469 : end function
7470 : #endif
7471 :
7472 : #if SK3_ENABLED
7473 : impure module function getUnifRandRNGSLU_D2_SK3(rng, lb, ub, s1, s2) result(rand)
7474 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7475 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_SK3
7476 : #endif
7477 : use pm_kind, only: SKC => SK3
7478 : character(*,SKC) , intent(in) :: lb, ub
7479 : integer(IK) , intent(in) :: s1, s2
7480 : character(len(lb,IK),SKC) :: rand(s1, s2)
7481 : type(splitmix64_type) , intent(inout) :: rng
7482 : end function
7483 : #endif
7484 :
7485 : #if SK2_ENABLED
7486 : impure module function getUnifRandRNGSLU_D2_SK2(rng, lb, ub, s1, s2) result(rand)
7487 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7488 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_SK2
7489 : #endif
7490 : use pm_kind, only: SKC => SK2
7491 : character(*,SKC) , intent(in) :: lb, ub
7492 : integer(IK) , intent(in) :: s1, s2
7493 : character(len(lb,IK),SKC) :: rand(s1, s2)
7494 : type(splitmix64_type) , intent(inout) :: rng
7495 : end function
7496 : #endif
7497 :
7498 : #if SK1_ENABLED
7499 : impure module function getUnifRandRNGSLU_D2_SK1(rng, lb, ub, s1, s2) result(rand)
7500 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7501 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_SK1
7502 : #endif
7503 : use pm_kind, only: SKC => SK1
7504 : character(*,SKC) , intent(in) :: lb, ub
7505 : integer(IK) , intent(in) :: s1, s2
7506 : character(len(lb,IK),SKC) :: rand(s1, s2)
7507 : type(splitmix64_type) , intent(inout) :: rng
7508 : end function
7509 : #endif
7510 :
7511 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7512 :
7513 : #if IK5_ENABLED
7514 : impure module function getUnifRandRNGSLU_D2_IK5(rng, lb, ub, s1, s2) result(rand)
7515 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7516 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_IK5
7517 : #endif
7518 : use pm_kind, only: IKC => IK5
7519 : integer(IKC) , intent(in) :: lb, ub
7520 : integer(IK) , intent(in) :: s1, s2
7521 : integer(IKC) :: rand(s1, s2)
7522 : type(splitmix64_type) , intent(inout) :: rng
7523 : end function
7524 : #endif
7525 :
7526 : #if IK4_ENABLED
7527 : impure module function getUnifRandRNGSLU_D2_IK4(rng, lb, ub, s1, s2) result(rand)
7528 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7529 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_IK4
7530 : #endif
7531 : use pm_kind, only: IKC => IK4
7532 : integer(IKC) , intent(in) :: lb, ub
7533 : integer(IK) , intent(in) :: s1, s2
7534 : integer(IKC) :: rand(s1, s2)
7535 : type(splitmix64_type) , intent(inout) :: rng
7536 : end function
7537 : #endif
7538 :
7539 : #if IK3_ENABLED
7540 : impure module function getUnifRandRNGSLU_D2_IK3(rng, lb, ub, s1, s2) result(rand)
7541 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7542 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_IK3
7543 : #endif
7544 : use pm_kind, only: IKC => IK3
7545 : integer(IKC) , intent(in) :: lb, ub
7546 : integer(IK) , intent(in) :: s1, s2
7547 : integer(IKC) :: rand(s1, s2)
7548 : type(splitmix64_type) , intent(inout) :: rng
7549 : end function
7550 : #endif
7551 :
7552 : #if IK2_ENABLED
7553 : impure module function getUnifRandRNGSLU_D2_IK2(rng, lb, ub, s1, s2) result(rand)
7554 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7555 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_IK2
7556 : #endif
7557 : use pm_kind, only: IKC => IK2
7558 : integer(IKC) , intent(in) :: lb, ub
7559 : integer(IK) , intent(in) :: s1, s2
7560 : integer(IKC) :: rand(s1, s2)
7561 : type(splitmix64_type) , intent(inout) :: rng
7562 : end function
7563 : #endif
7564 :
7565 : #if IK1_ENABLED
7566 : impure module function getUnifRandRNGSLU_D2_IK1(rng, lb, ub, s1, s2) result(rand)
7567 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7568 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_IK1
7569 : #endif
7570 : use pm_kind, only: IKC => IK1
7571 : integer(IKC) , intent(in) :: lb, ub
7572 : integer(IK) , intent(in) :: s1, s2
7573 : integer(IKC) :: rand(s1, s2)
7574 : type(splitmix64_type) , intent(inout) :: rng
7575 : end function
7576 : #endif
7577 :
7578 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7579 :
7580 : #if LK5_ENABLED
7581 : impure module function getUnifRandRNGSLU_D2_LK5(rng, lb, ub, s1, s2) result(rand)
7582 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7583 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_LK5
7584 : #endif
7585 : use pm_kind, only: LKC => LK5
7586 : logical(LKC) , intent(in) :: lb, ub
7587 : integer(IK) , intent(in) :: s1, s2
7588 : logical(LKC) :: rand(s1, s2)
7589 : type(splitmix64_type) , intent(inout) :: rng
7590 : end function
7591 : #endif
7592 :
7593 : #if LK4_ENABLED
7594 : impure module function getUnifRandRNGSLU_D2_LK4(rng, lb, ub, s1, s2) result(rand)
7595 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7596 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_LK4
7597 : #endif
7598 : use pm_kind, only: LKC => LK4
7599 : logical(LKC) , intent(in) :: lb, ub
7600 : integer(IK) , intent(in) :: s1, s2
7601 : logical(LKC) :: rand(s1, s2)
7602 : type(splitmix64_type) , intent(inout) :: rng
7603 : end function
7604 : #endif
7605 :
7606 : #if LK3_ENABLED
7607 : impure module function getUnifRandRNGSLU_D2_LK3(rng, lb, ub, s1, s2) result(rand)
7608 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7609 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_LK3
7610 : #endif
7611 : use pm_kind, only: LKC => LK3
7612 : logical(LKC) , intent(in) :: lb, ub
7613 : integer(IK) , intent(in) :: s1, s2
7614 : logical(LKC) :: rand(s1, s2)
7615 : type(splitmix64_type) , intent(inout) :: rng
7616 : end function
7617 : #endif
7618 :
7619 : #if LK2_ENABLED
7620 : impure module function getUnifRandRNGSLU_D2_LK2(rng, lb, ub, s1, s2) result(rand)
7621 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7622 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_LK2
7623 : #endif
7624 : use pm_kind, only: LKC => LK2
7625 : logical(LKC) , intent(in) :: lb, ub
7626 : integer(IK) , intent(in) :: s1, s2
7627 : logical(LKC) :: rand(s1, s2)
7628 : type(splitmix64_type) , intent(inout) :: rng
7629 : end function
7630 : #endif
7631 :
7632 : #if LK1_ENABLED
7633 : impure module function getUnifRandRNGSLU_D2_LK1(rng, lb, ub, s1, s2) result(rand)
7634 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7635 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_LK1
7636 : #endif
7637 : use pm_kind, only: LKC => LK1
7638 : logical(LKC) , intent(in) :: lb, ub
7639 : integer(IK) , intent(in) :: s1, s2
7640 : logical(LKC) :: rand(s1, s2)
7641 : type(splitmix64_type) , intent(inout) :: rng
7642 : end function
7643 : #endif
7644 :
7645 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7646 :
7647 : #if CK5_ENABLED
7648 : impure module function getUnifRandRNGSLU_D2_CK5(rng, lb, ub, s1, s2) result(rand)
7649 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7650 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_CK5
7651 : #endif
7652 : use pm_kind, only: CKC => CK5
7653 : complex(CKC) , intent(in) :: lb, ub
7654 : integer(IK) , intent(in) :: s1, s2
7655 : complex(CKC) :: rand(s1, s2)
7656 : type(splitmix64_type) , intent(inout) :: rng
7657 : end function
7658 : #endif
7659 :
7660 : #if CK4_ENABLED
7661 : impure module function getUnifRandRNGSLU_D2_CK4(rng, lb, ub, s1, s2) result(rand)
7662 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7663 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_CK4
7664 : #endif
7665 : use pm_kind, only: CKC => CK4
7666 : complex(CKC) , intent(in) :: lb, ub
7667 : integer(IK) , intent(in) :: s1, s2
7668 : complex(CKC) :: rand(s1, s2)
7669 : type(splitmix64_type) , intent(inout) :: rng
7670 : end function
7671 : #endif
7672 :
7673 : #if CK3_ENABLED
7674 : impure module function getUnifRandRNGSLU_D2_CK3(rng, lb, ub, s1, s2) result(rand)
7675 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7676 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_CK3
7677 : #endif
7678 : use pm_kind, only: CKC => CK3
7679 : complex(CKC) , intent(in) :: lb, ub
7680 : integer(IK) , intent(in) :: s1, s2
7681 : complex(CKC) :: rand(s1, s2)
7682 : type(splitmix64_type) , intent(inout) :: rng
7683 : end function
7684 : #endif
7685 :
7686 : #if CK2_ENABLED
7687 : impure module function getUnifRandRNGSLU_D2_CK2(rng, lb, ub, s1, s2) result(rand)
7688 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7689 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_CK2
7690 : #endif
7691 : use pm_kind, only: CKC => CK2
7692 : complex(CKC) , intent(in) :: lb, ub
7693 : integer(IK) , intent(in) :: s1, s2
7694 : complex(CKC) :: rand(s1, s2)
7695 : type(splitmix64_type) , intent(inout) :: rng
7696 : end function
7697 : #endif
7698 :
7699 : #if CK1_ENABLED
7700 : impure module function getUnifRandRNGSLU_D2_CK1(rng, lb, ub, s1, s2) result(rand)
7701 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7702 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_CK1
7703 : #endif
7704 : use pm_kind, only: CKC => CK1
7705 : complex(CKC) , intent(in) :: lb, ub
7706 : integer(IK) , intent(in) :: s1, s2
7707 : complex(CKC) :: rand(s1, s2)
7708 : type(splitmix64_type) , intent(inout) :: rng
7709 : end function
7710 : #endif
7711 :
7712 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7713 :
7714 : #if RK5_ENABLED
7715 : impure module function getUnifRandRNGSLU_D2_RK5(rng, lb, ub, s1, s2) result(rand)
7716 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7717 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_RK5
7718 : #endif
7719 : use pm_kind, only: RKC => RK5
7720 : real(RKC) , intent(in) :: lb, ub
7721 : integer(IK) , intent(in) :: s1, s2
7722 : real(RKC) :: rand(s1, s2)
7723 : type(splitmix64_type) , intent(inout) :: rng
7724 : end function
7725 :
7726 : #endif
7727 :
7728 : #if RK4_ENABLED
7729 : impure module function getUnifRandRNGSLU_D2_RK4(rng, lb, ub, s1, s2) result(rand)
7730 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7731 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_RK4
7732 : #endif
7733 : use pm_kind, only: RKC => RK4
7734 : real(RKC) , intent(in) :: lb, ub
7735 : integer(IK) , intent(in) :: s1, s2
7736 : real(RKC) :: rand(s1, s2)
7737 : type(splitmix64_type) , intent(inout) :: rng
7738 : end function
7739 :
7740 : #endif
7741 :
7742 : #if RK3_ENABLED
7743 : impure module function getUnifRandRNGSLU_D2_RK3(rng, lb, ub, s1, s2) result(rand)
7744 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7745 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_RK3
7746 : #endif
7747 : use pm_kind, only: RKC => RK3
7748 : real(RKC) , intent(in) :: lb, ub
7749 : integer(IK) , intent(in) :: s1, s2
7750 : real(RKC) :: rand(s1, s2)
7751 : type(splitmix64_type) , intent(inout) :: rng
7752 : end function
7753 :
7754 : #endif
7755 :
7756 : #if RK2_ENABLED
7757 : impure module function getUnifRandRNGSLU_D2_RK2(rng, lb, ub, s1, s2) result(rand)
7758 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7759 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_RK2
7760 : #endif
7761 : use pm_kind, only: RKC => RK2
7762 : real(RKC) , intent(in) :: lb, ub
7763 : integer(IK) , intent(in) :: s1, s2
7764 : real(RKC) :: rand(s1, s2)
7765 : type(splitmix64_type) , intent(inout) :: rng
7766 : end function
7767 : #endif
7768 :
7769 : #if RK1_ENABLED
7770 : impure module function getUnifRandRNGSLU_D2_RK1(rng, lb, ub, s1, s2) result(rand)
7771 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7772 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D2_RK1
7773 : #endif
7774 : use pm_kind, only: RKC => RK1
7775 : real(RKC) , intent(in) :: lb, ub
7776 : integer(IK) , intent(in) :: s1, s2
7777 : real(RKC) :: rand(s1, s2)
7778 : type(splitmix64_type) , intent(inout) :: rng
7779 : end function
7780 : #endif
7781 :
7782 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7783 :
7784 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7785 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7786 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7787 :
7788 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7789 :
7790 : #if SK5_ENABLED
7791 : impure module function getUnifRandRNGSLU_D3_SK5(rng, lb, ub, s1, s2, s3) result(rand)
7792 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7793 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_SK5
7794 : #endif
7795 : use pm_kind, only: SKC => SK5
7796 : character(*,SKC) , intent(in) :: lb, ub
7797 : integer(IK) , intent(in) :: s1, s2, s3
7798 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
7799 : type(splitmix64_type) , intent(inout) :: rng
7800 : end function
7801 : #endif
7802 :
7803 : #if SK4_ENABLED
7804 : impure module function getUnifRandRNGSLU_D3_SK4(rng, lb, ub, s1, s2, s3) result(rand)
7805 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7806 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_SK4
7807 : #endif
7808 : use pm_kind, only: SKC => SK4
7809 : character(*,SKC) , intent(in) :: lb, ub
7810 : integer(IK) , intent(in) :: s1, s2, s3
7811 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
7812 : type(splitmix64_type) , intent(inout) :: rng
7813 : end function
7814 : #endif
7815 :
7816 : #if SK3_ENABLED
7817 : impure module function getUnifRandRNGSLU_D3_SK3(rng, lb, ub, s1, s2, s3) result(rand)
7818 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7819 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_SK3
7820 : #endif
7821 : use pm_kind, only: SKC => SK3
7822 : character(*,SKC) , intent(in) :: lb, ub
7823 : integer(IK) , intent(in) :: s1, s2, s3
7824 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
7825 : type(splitmix64_type) , intent(inout) :: rng
7826 : end function
7827 : #endif
7828 :
7829 : #if SK2_ENABLED
7830 : impure module function getUnifRandRNGSLU_D3_SK2(rng, lb, ub, s1, s2, s3) result(rand)
7831 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7832 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_SK2
7833 : #endif
7834 : use pm_kind, only: SKC => SK2
7835 : character(*,SKC) , intent(in) :: lb, ub
7836 : integer(IK) , intent(in) :: s1, s2, s3
7837 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
7838 : type(splitmix64_type) , intent(inout) :: rng
7839 : end function
7840 : #endif
7841 :
7842 : #if SK1_ENABLED
7843 : impure module function getUnifRandRNGSLU_D3_SK1(rng, lb, ub, s1, s2, s3) result(rand)
7844 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7845 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_SK1
7846 : #endif
7847 : use pm_kind, only: SKC => SK1
7848 : character(*,SKC) , intent(in) :: lb, ub
7849 : integer(IK) , intent(in) :: s1, s2, s3
7850 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
7851 : type(splitmix64_type) , intent(inout) :: rng
7852 : end function
7853 : #endif
7854 :
7855 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7856 :
7857 : #if IK5_ENABLED
7858 : impure module function getUnifRandRNGSLU_D3_IK5(rng, lb, ub, s1, s2, s3) result(rand)
7859 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7860 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_IK5
7861 : #endif
7862 : use pm_kind, only: IKC => IK5
7863 : integer(IKC) , intent(in) :: lb, ub
7864 : integer(IK) , intent(in) :: s1, s2, s3
7865 : integer(IKC) :: rand(s1, s2, s3)
7866 : type(splitmix64_type) , intent(inout) :: rng
7867 : end function
7868 : #endif
7869 :
7870 : #if IK4_ENABLED
7871 : impure module function getUnifRandRNGSLU_D3_IK4(rng, lb, ub, s1, s2, s3) result(rand)
7872 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7873 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_IK4
7874 : #endif
7875 : use pm_kind, only: IKC => IK4
7876 : integer(IKC) , intent(in) :: lb, ub
7877 : integer(IK) , intent(in) :: s1, s2, s3
7878 : integer(IKC) :: rand(s1, s2, s3)
7879 : type(splitmix64_type) , intent(inout) :: rng
7880 : end function
7881 : #endif
7882 :
7883 : #if IK3_ENABLED
7884 : impure module function getUnifRandRNGSLU_D3_IK3(rng, lb, ub, s1, s2, s3) result(rand)
7885 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7886 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_IK3
7887 : #endif
7888 : use pm_kind, only: IKC => IK3
7889 : integer(IKC) , intent(in) :: lb, ub
7890 : integer(IK) , intent(in) :: s1, s2, s3
7891 : integer(IKC) :: rand(s1, s2, s3)
7892 : type(splitmix64_type) , intent(inout) :: rng
7893 : end function
7894 : #endif
7895 :
7896 : #if IK2_ENABLED
7897 : impure module function getUnifRandRNGSLU_D3_IK2(rng, lb, ub, s1, s2, s3) result(rand)
7898 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7899 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_IK2
7900 : #endif
7901 : use pm_kind, only: IKC => IK2
7902 : integer(IKC) , intent(in) :: lb, ub
7903 : integer(IK) , intent(in) :: s1, s2, s3
7904 : integer(IKC) :: rand(s1, s2, s3)
7905 : type(splitmix64_type) , intent(inout) :: rng
7906 : end function
7907 : #endif
7908 :
7909 : #if IK1_ENABLED
7910 : impure module function getUnifRandRNGSLU_D3_IK1(rng, lb, ub, s1, s2, s3) result(rand)
7911 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7912 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_IK1
7913 : #endif
7914 : use pm_kind, only: IKC => IK1
7915 : integer(IKC) , intent(in) :: lb, ub
7916 : integer(IK) , intent(in) :: s1, s2, s3
7917 : integer(IKC) :: rand(s1, s2, s3)
7918 : type(splitmix64_type) , intent(inout) :: rng
7919 : end function
7920 : #endif
7921 :
7922 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7923 :
7924 : #if LK5_ENABLED
7925 : impure module function getUnifRandRNGSLU_D3_LK5(rng, lb, ub, s1, s2, s3) result(rand)
7926 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7927 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_LK5
7928 : #endif
7929 : use pm_kind, only: LKC => LK5
7930 : logical(LKC) , intent(in) :: lb, ub
7931 : integer(IK) , intent(in) :: s1, s2, s3
7932 : logical(LKC) :: rand(s1, s2, s3)
7933 : type(splitmix64_type) , intent(inout) :: rng
7934 : end function
7935 : #endif
7936 :
7937 : #if LK4_ENABLED
7938 : impure module function getUnifRandRNGSLU_D3_LK4(rng, lb, ub, s1, s2, s3) result(rand)
7939 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7940 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_LK4
7941 : #endif
7942 : use pm_kind, only: LKC => LK4
7943 : logical(LKC) , intent(in) :: lb, ub
7944 : integer(IK) , intent(in) :: s1, s2, s3
7945 : logical(LKC) :: rand(s1, s2, s3)
7946 : type(splitmix64_type) , intent(inout) :: rng
7947 : end function
7948 : #endif
7949 :
7950 : #if LK3_ENABLED
7951 : impure module function getUnifRandRNGSLU_D3_LK3(rng, lb, ub, s1, s2, s3) result(rand)
7952 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7953 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_LK3
7954 : #endif
7955 : use pm_kind, only: LKC => LK3
7956 : logical(LKC) , intent(in) :: lb, ub
7957 : integer(IK) , intent(in) :: s1, s2, s3
7958 : logical(LKC) :: rand(s1, s2, s3)
7959 : type(splitmix64_type) , intent(inout) :: rng
7960 : end function
7961 : #endif
7962 :
7963 : #if LK2_ENABLED
7964 : impure module function getUnifRandRNGSLU_D3_LK2(rng, lb, ub, s1, s2, s3) result(rand)
7965 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7966 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_LK2
7967 : #endif
7968 : use pm_kind, only: LKC => LK2
7969 : logical(LKC) , intent(in) :: lb, ub
7970 : integer(IK) , intent(in) :: s1, s2, s3
7971 : logical(LKC) :: rand(s1, s2, s3)
7972 : type(splitmix64_type) , intent(inout) :: rng
7973 : end function
7974 : #endif
7975 :
7976 : #if LK1_ENABLED
7977 : impure module function getUnifRandRNGSLU_D3_LK1(rng, lb, ub, s1, s2, s3) result(rand)
7978 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7979 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_LK1
7980 : #endif
7981 : use pm_kind, only: LKC => LK1
7982 : logical(LKC) , intent(in) :: lb, ub
7983 : integer(IK) , intent(in) :: s1, s2, s3
7984 : logical(LKC) :: rand(s1, s2, s3)
7985 : type(splitmix64_type) , intent(inout) :: rng
7986 : end function
7987 : #endif
7988 :
7989 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7990 :
7991 : #if CK5_ENABLED
7992 : impure module function getUnifRandRNGSLU_D3_CK5(rng, lb, ub, s1, s2, s3) result(rand)
7993 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7994 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_CK5
7995 : #endif
7996 : use pm_kind, only: CKC => CK5
7997 : complex(CKC) , intent(in) :: lb, ub
7998 : integer(IK) , intent(in) :: s1, s2, s3
7999 : complex(CKC) :: rand(s1, s2, s3)
8000 : type(splitmix64_type) , intent(inout) :: rng
8001 : end function
8002 : #endif
8003 :
8004 : #if CK4_ENABLED
8005 : impure module function getUnifRandRNGSLU_D3_CK4(rng, lb, ub, s1, s2, s3) result(rand)
8006 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8007 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_CK4
8008 : #endif
8009 : use pm_kind, only: CKC => CK4
8010 : complex(CKC) , intent(in) :: lb, ub
8011 : integer(IK) , intent(in) :: s1, s2, s3
8012 : complex(CKC) :: rand(s1, s2, s3)
8013 : type(splitmix64_type) , intent(inout) :: rng
8014 : end function
8015 : #endif
8016 :
8017 : #if CK3_ENABLED
8018 : impure module function getUnifRandRNGSLU_D3_CK3(rng, lb, ub, s1, s2, s3) result(rand)
8019 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8020 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_CK3
8021 : #endif
8022 : use pm_kind, only: CKC => CK3
8023 : complex(CKC) , intent(in) :: lb, ub
8024 : integer(IK) , intent(in) :: s1, s2, s3
8025 : complex(CKC) :: rand(s1, s2, s3)
8026 : type(splitmix64_type) , intent(inout) :: rng
8027 : end function
8028 : #endif
8029 :
8030 : #if CK2_ENABLED
8031 : impure module function getUnifRandRNGSLU_D3_CK2(rng, lb, ub, s1, s2, s3) result(rand)
8032 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8033 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_CK2
8034 : #endif
8035 : use pm_kind, only: CKC => CK2
8036 : complex(CKC) , intent(in) :: lb, ub
8037 : integer(IK) , intent(in) :: s1, s2, s3
8038 : complex(CKC) :: rand(s1, s2, s3)
8039 : type(splitmix64_type) , intent(inout) :: rng
8040 : end function
8041 : #endif
8042 :
8043 : #if CK1_ENABLED
8044 : impure module function getUnifRandRNGSLU_D3_CK1(rng, lb, ub, s1, s2, s3) result(rand)
8045 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8046 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_CK1
8047 : #endif
8048 : use pm_kind, only: CKC => CK1
8049 : complex(CKC) , intent(in) :: lb, ub
8050 : integer(IK) , intent(in) :: s1, s2, s3
8051 : complex(CKC) :: rand(s1, s2, s3)
8052 : type(splitmix64_type) , intent(inout) :: rng
8053 : end function
8054 : #endif
8055 :
8056 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8057 :
8058 : #if RK5_ENABLED
8059 : impure module function getUnifRandRNGSLU_D3_RK5(rng, lb, ub, s1, s2, s3) result(rand)
8060 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8061 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_RK5
8062 : #endif
8063 : use pm_kind, only: RKC => RK5
8064 : real(RKC) , intent(in) :: lb, ub
8065 : integer(IK) , intent(in) :: s1, s2, s3
8066 : real(RKC) :: rand(s1, s2, s3)
8067 : type(splitmix64_type) , intent(inout) :: rng
8068 : end function
8069 :
8070 : #endif
8071 :
8072 : #if RK4_ENABLED
8073 : impure module function getUnifRandRNGSLU_D3_RK4(rng, lb, ub, s1, s2, s3) result(rand)
8074 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8075 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_RK4
8076 : #endif
8077 : use pm_kind, only: RKC => RK4
8078 : real(RKC) , intent(in) :: lb, ub
8079 : integer(IK) , intent(in) :: s1, s2, s3
8080 : real(RKC) :: rand(s1, s2, s3)
8081 : type(splitmix64_type) , intent(inout) :: rng
8082 : end function
8083 :
8084 : #endif
8085 :
8086 : #if RK3_ENABLED
8087 : impure module function getUnifRandRNGSLU_D3_RK3(rng, lb, ub, s1, s2, s3) result(rand)
8088 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8089 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_RK3
8090 : #endif
8091 : use pm_kind, only: RKC => RK3
8092 : real(RKC) , intent(in) :: lb, ub
8093 : integer(IK) , intent(in) :: s1, s2, s3
8094 : real(RKC) :: rand(s1, s2, s3)
8095 : type(splitmix64_type) , intent(inout) :: rng
8096 : end function
8097 :
8098 : #endif
8099 :
8100 : #if RK2_ENABLED
8101 : impure module function getUnifRandRNGSLU_D3_RK2(rng, lb, ub, s1, s2, s3) result(rand)
8102 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8103 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_RK2
8104 : #endif
8105 : use pm_kind, only: RKC => RK2
8106 : real(RKC) , intent(in) :: lb, ub
8107 : integer(IK) , intent(in) :: s1, s2, s3
8108 : real(RKC) :: rand(s1, s2, s3)
8109 : type(splitmix64_type) , intent(inout) :: rng
8110 : end function
8111 : #endif
8112 :
8113 : #if RK1_ENABLED
8114 : impure module function getUnifRandRNGSLU_D3_RK1(rng, lb, ub, s1, s2, s3) result(rand)
8115 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8116 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGSLU_D3_RK1
8117 : #endif
8118 : use pm_kind, only: RKC => RK1
8119 : real(RKC) , intent(in) :: lb, ub
8120 : integer(IK) , intent(in) :: s1, s2, s3
8121 : real(RKC) :: rand(s1, s2, s3)
8122 : type(splitmix64_type) , intent(inout) :: rng
8123 : end function
8124 : #endif
8125 :
8126 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8127 :
8128 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8129 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8130 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8131 :
8132 : end interface
8133 :
8134 : ! RNGX
8135 :
8136 : interface getUnifRand
8137 :
8138 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8139 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8140 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8141 :
8142 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8143 :
8144 : impure module function getUnifRandRNGXDD_D0_LK(rng) result(rand)
8145 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8146 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXDD_D0_LK
8147 : #endif
8148 : use pm_kind, only: LKC => LK
8149 : logical(LKC) :: rand
8150 : type(xoshiro256ssw_type) , intent(inout) :: rng
8151 : end function
8152 :
8153 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8154 :
8155 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8156 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8157 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8158 :
8159 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8160 :
8161 : #if SK5_ENABLED
8162 : impure elemental module function getUnifRandRNGXLU_D0_SK5(rng, lb, ub) result(rand)
8163 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8164 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_SK5
8165 : #endif
8166 : use pm_kind, only: SKC => SK5
8167 : character(*,SKC) , intent(in) :: lb, ub
8168 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
8169 : type(xoshiro256ssw_type) , intent(inout) :: rng
8170 : end function
8171 : #endif
8172 :
8173 : #if SK4_ENABLED
8174 : impure elemental module function getUnifRandRNGXLU_D0_SK4(rng, lb, ub) result(rand)
8175 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8176 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_SK4
8177 : #endif
8178 : use pm_kind, only: SKC => SK4
8179 : character(*,SKC) , intent(in) :: lb, ub
8180 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
8181 : type(xoshiro256ssw_type) , intent(inout) :: rng
8182 : end function
8183 : #endif
8184 :
8185 : #if SK3_ENABLED
8186 : impure elemental module function getUnifRandRNGXLU_D0_SK3(rng, lb, ub) result(rand)
8187 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8188 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_SK3
8189 : #endif
8190 : use pm_kind, only: SKC => SK3
8191 : character(*,SKC) , intent(in) :: lb, ub
8192 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
8193 : type(xoshiro256ssw_type) , intent(inout) :: rng
8194 : end function
8195 : #endif
8196 :
8197 : #if SK2_ENABLED
8198 : impure elemental module function getUnifRandRNGXLU_D0_SK2(rng, lb, ub) result(rand)
8199 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8200 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_SK2
8201 : #endif
8202 : use pm_kind, only: SKC => SK2
8203 : character(*,SKC) , intent(in) :: lb, ub
8204 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
8205 : type(xoshiro256ssw_type) , intent(inout) :: rng
8206 : end function
8207 : #endif
8208 :
8209 : #if SK1_ENABLED
8210 : impure elemental module function getUnifRandRNGXLU_D0_SK1(rng, lb, ub) result(rand)
8211 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8212 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_SK1
8213 : #endif
8214 : use pm_kind, only: SKC => SK1
8215 : character(*,SKC) , intent(in) :: lb, ub
8216 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
8217 : type(xoshiro256ssw_type) , intent(inout) :: rng
8218 : end function
8219 : #endif
8220 :
8221 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8222 :
8223 : #if IK5_ENABLED
8224 : impure elemental module function getUnifRandRNGXLU_D0_IK5(rng, lb, ub) result(rand)
8225 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8226 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_IK5
8227 : #endif
8228 : use pm_kind, only: IKC => IK5
8229 : integer(IKC) , intent(in) :: lb, ub
8230 : integer(IKC) :: rand
8231 : type(xoshiro256ssw_type) , intent(inout) :: rng
8232 : end function
8233 : #endif
8234 :
8235 : #if IK4_ENABLED
8236 : impure elemental module function getUnifRandRNGXLU_D0_IK4(rng, lb, ub) result(rand)
8237 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8238 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_IK4
8239 : #endif
8240 : use pm_kind, only: IKC => IK4
8241 : integer(IKC) , intent(in) :: lb, ub
8242 : integer(IKC) :: rand
8243 : type(xoshiro256ssw_type) , intent(inout) :: rng
8244 : end function
8245 : #endif
8246 :
8247 : #if IK3_ENABLED
8248 : impure elemental module function getUnifRandRNGXLU_D0_IK3(rng, lb, ub) result(rand)
8249 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8250 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_IK3
8251 : #endif
8252 : use pm_kind, only: IKC => IK3
8253 : integer(IKC) , intent(in) :: lb, ub
8254 : integer(IKC) :: rand
8255 : type(xoshiro256ssw_type) , intent(inout) :: rng
8256 : end function
8257 : #endif
8258 :
8259 : #if IK2_ENABLED
8260 : impure elemental module function getUnifRandRNGXLU_D0_IK2(rng, lb, ub) result(rand)
8261 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8262 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_IK2
8263 : #endif
8264 : use pm_kind, only: IKC => IK2
8265 : integer(IKC) , intent(in) :: lb, ub
8266 : integer(IKC) :: rand
8267 : type(xoshiro256ssw_type) , intent(inout) :: rng
8268 : end function
8269 : #endif
8270 :
8271 : #if IK1_ENABLED
8272 : impure elemental module function getUnifRandRNGXLU_D0_IK1(rng, lb, ub) result(rand)
8273 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8274 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_IK1
8275 : #endif
8276 : use pm_kind, only: IKC => IK1
8277 : integer(IKC) , intent(in) :: lb, ub
8278 : integer(IKC) :: rand
8279 : type(xoshiro256ssw_type) , intent(inout) :: rng
8280 : end function
8281 : #endif
8282 :
8283 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8284 :
8285 : #if LK5_ENABLED
8286 : impure elemental module function getUnifRandRNGXLU_D0_LK5(rng, lb, ub) result(rand)
8287 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8288 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_LK5
8289 : #endif
8290 : use pm_kind, only: LKC => LK5
8291 : logical(LKC) , intent(in) :: lb, ub
8292 : logical(LKC) :: rand
8293 : type(xoshiro256ssw_type) , intent(inout) :: rng
8294 : end function
8295 : #endif
8296 :
8297 : #if LK4_ENABLED
8298 : impure elemental module function getUnifRandRNGXLU_D0_LK4(rng, lb, ub) result(rand)
8299 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8300 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_LK4
8301 : #endif
8302 : use pm_kind, only: LKC => LK4
8303 : logical(LKC) , intent(in) :: lb, ub
8304 : logical(LKC) :: rand
8305 : type(xoshiro256ssw_type) , intent(inout) :: rng
8306 : end function
8307 : #endif
8308 :
8309 : #if LK3_ENABLED
8310 : impure elemental module function getUnifRandRNGXLU_D0_LK3(rng, lb, ub) result(rand)
8311 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8312 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_LK3
8313 : #endif
8314 : use pm_kind, only: LKC => LK3
8315 : logical(LKC) , intent(in) :: lb, ub
8316 : logical(LKC) :: rand
8317 : type(xoshiro256ssw_type) , intent(inout) :: rng
8318 : end function
8319 : #endif
8320 :
8321 : #if LK2_ENABLED
8322 : impure elemental module function getUnifRandRNGXLU_D0_LK2(rng, lb, ub) result(rand)
8323 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8324 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_LK2
8325 : #endif
8326 : use pm_kind, only: LKC => LK2
8327 : logical(LKC) , intent(in) :: lb, ub
8328 : logical(LKC) :: rand
8329 : type(xoshiro256ssw_type) , intent(inout) :: rng
8330 : end function
8331 : #endif
8332 :
8333 : #if LK1_ENABLED
8334 : impure elemental module function getUnifRandRNGXLU_D0_LK1(rng, lb, ub) result(rand)
8335 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8336 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_LK1
8337 : #endif
8338 : use pm_kind, only: LKC => LK1
8339 : logical(LKC) , intent(in) :: lb, ub
8340 : logical(LKC) :: rand
8341 : type(xoshiro256ssw_type) , intent(inout) :: rng
8342 : end function
8343 : #endif
8344 :
8345 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8346 :
8347 : #if CK5_ENABLED
8348 : impure elemental module function getUnifRandRNGXLU_D0_CK5(rng, lb, ub) result(rand)
8349 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8350 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_CK5
8351 : #endif
8352 : use pm_kind, only: CKC => CK5
8353 : complex(CKC) , intent(in) :: lb, ub
8354 : complex(CKC) :: rand
8355 : type(xoshiro256ssw_type) , intent(inout) :: rng
8356 : end function
8357 : #endif
8358 :
8359 : #if CK4_ENABLED
8360 : impure elemental module function getUnifRandRNGXLU_D0_CK4(rng, lb, ub) result(rand)
8361 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8362 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_CK4
8363 : #endif
8364 : use pm_kind, only: CKC => CK4
8365 : complex(CKC) , intent(in) :: lb, ub
8366 : complex(CKC) :: rand
8367 : type(xoshiro256ssw_type) , intent(inout) :: rng
8368 : end function
8369 : #endif
8370 :
8371 : #if CK3_ENABLED
8372 : impure elemental module function getUnifRandRNGXLU_D0_CK3(rng, lb, ub) result(rand)
8373 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8374 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_CK3
8375 : #endif
8376 : use pm_kind, only: CKC => CK3
8377 : complex(CKC) , intent(in) :: lb, ub
8378 : complex(CKC) :: rand
8379 : type(xoshiro256ssw_type) , intent(inout) :: rng
8380 : end function
8381 : #endif
8382 :
8383 : #if CK2_ENABLED
8384 : impure elemental module function getUnifRandRNGXLU_D0_CK2(rng, lb, ub) result(rand)
8385 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8386 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_CK2
8387 : #endif
8388 : use pm_kind, only: CKC => CK2
8389 : complex(CKC) , intent(in) :: lb, ub
8390 : complex(CKC) :: rand
8391 : type(xoshiro256ssw_type) , intent(inout) :: rng
8392 : end function
8393 : #endif
8394 :
8395 : #if CK1_ENABLED
8396 : impure elemental module function getUnifRandRNGXLU_D0_CK1(rng, lb, ub) result(rand)
8397 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8398 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_CK1
8399 : #endif
8400 : use pm_kind, only: CKC => CK1
8401 : complex(CKC) , intent(in) :: lb, ub
8402 : complex(CKC) :: rand
8403 : type(xoshiro256ssw_type) , intent(inout) :: rng
8404 : end function
8405 : #endif
8406 :
8407 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8408 :
8409 : #if RK5_ENABLED
8410 : impure elemental module function getUnifRandRNGXLU_D0_RK5(rng, lb, ub) result(rand)
8411 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8412 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_RK5
8413 : #endif
8414 : use pm_kind, only: RKC => RK5
8415 : real(RKC) , intent(in) :: lb, ub
8416 : real(RKC) :: rand
8417 : type(xoshiro256ssw_type) , intent(inout) :: rng
8418 : end function
8419 : #endif
8420 :
8421 : #if RK4_ENABLED
8422 : impure elemental module function getUnifRandRNGXLU_D0_RK4(rng, lb, ub) result(rand)
8423 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8424 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_RK4
8425 : #endif
8426 : use pm_kind, only: RKC => RK4
8427 : real(RKC) , intent(in) :: lb, ub
8428 : real(RKC) :: rand
8429 : type(xoshiro256ssw_type) , intent(inout) :: rng
8430 : end function
8431 : #endif
8432 :
8433 : #if RK3_ENABLED
8434 : impure elemental module function getUnifRandRNGXLU_D0_RK3(rng, lb, ub) result(rand)
8435 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8436 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_RK3
8437 : #endif
8438 : use pm_kind, only: RKC => RK3
8439 : real(RKC) , intent(in) :: lb, ub
8440 : real(RKC) :: rand
8441 : type(xoshiro256ssw_type) , intent(inout) :: rng
8442 : end function
8443 : #endif
8444 :
8445 : #if RK2_ENABLED
8446 : impure elemental module function getUnifRandRNGXLU_D0_RK2(rng, lb, ub) result(rand)
8447 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8448 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_RK2
8449 : #endif
8450 : use pm_kind, only: RKC => RK2
8451 : real(RKC) , intent(in) :: lb, ub
8452 : real(RKC) :: rand
8453 : type(xoshiro256ssw_type) , intent(inout) :: rng
8454 : end function
8455 : #endif
8456 :
8457 : #if RK1_ENABLED
8458 : impure elemental module function getUnifRandRNGXLU_D0_RK1(rng, lb, ub) result(rand)
8459 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8460 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D0_RK1
8461 : #endif
8462 : use pm_kind, only: RKC => RK1
8463 : real(RKC) , intent(in) :: lb, ub
8464 : real(RKC) :: rand
8465 : type(xoshiro256ssw_type) , intent(inout) :: rng
8466 : end function
8467 : #endif
8468 :
8469 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8470 :
8471 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8472 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8473 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8474 :
8475 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8476 :
8477 : #if SK5_ENABLED
8478 : impure module function getUnifRandRNGXLU_D1_SK5(rng, lb, ub, s1) result(rand)
8479 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8480 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_SK5
8481 : #endif
8482 : use pm_kind, only: SKC => SK5
8483 : character(*,SKC) , intent(in) :: lb, ub
8484 : integer(IK) , intent(in) :: s1
8485 : character(len(lb,IK),SKC) :: rand(s1)
8486 : type(xoshiro256ssw_type) , intent(inout) :: rng
8487 : end function
8488 : #endif
8489 :
8490 : #if SK4_ENABLED
8491 : impure module function getUnifRandRNGXLU_D1_SK4(rng, lb, ub, s1) result(rand)
8492 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8493 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_SK4
8494 : #endif
8495 : use pm_kind, only: SKC => SK4
8496 : character(*,SKC) , intent(in) :: lb, ub
8497 : integer(IK) , intent(in) :: s1
8498 : character(len(lb,IK),SKC) :: rand(s1)
8499 : type(xoshiro256ssw_type) , intent(inout) :: rng
8500 : end function
8501 : #endif
8502 :
8503 : #if SK3_ENABLED
8504 : impure module function getUnifRandRNGXLU_D1_SK3(rng, lb, ub, s1) result(rand)
8505 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8506 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_SK3
8507 : #endif
8508 : use pm_kind, only: SKC => SK3
8509 : character(*,SKC) , intent(in) :: lb, ub
8510 : integer(IK) , intent(in) :: s1
8511 : character(len(lb,IK),SKC) :: rand(s1)
8512 : type(xoshiro256ssw_type) , intent(inout) :: rng
8513 : end function
8514 : #endif
8515 :
8516 : #if SK2_ENABLED
8517 : impure module function getUnifRandRNGXLU_D1_SK2(rng, lb, ub, s1) result(rand)
8518 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8519 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_SK2
8520 : #endif
8521 : use pm_kind, only: SKC => SK2
8522 : character(*,SKC) , intent(in) :: lb, ub
8523 : integer(IK) , intent(in) :: s1
8524 : character(len(lb,IK),SKC) :: rand(s1)
8525 : type(xoshiro256ssw_type) , intent(inout) :: rng
8526 : end function
8527 : #endif
8528 :
8529 : #if SK1_ENABLED
8530 : impure module function getUnifRandRNGXLU_D1_SK1(rng, lb, ub, s1) result(rand)
8531 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8532 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_SK1
8533 : #endif
8534 : use pm_kind, only: SKC => SK1
8535 : character(*,SKC) , intent(in) :: lb, ub
8536 : integer(IK) , intent(in) :: s1
8537 : character(len(lb,IK),SKC) :: rand(s1)
8538 : type(xoshiro256ssw_type) , intent(inout) :: rng
8539 : end function
8540 : #endif
8541 :
8542 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8543 :
8544 : #if IK5_ENABLED
8545 : impure module function getUnifRandRNGXLU_D1_IK5(rng, lb, ub, s1) result(rand)
8546 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8547 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_IK5
8548 : #endif
8549 : use pm_kind, only: IKC => IK5
8550 : integer(IKC) , intent(in) :: lb, ub
8551 : integer(IK) , intent(in) :: s1
8552 : integer(IKC) :: rand(s1)
8553 : type(xoshiro256ssw_type) , intent(inout) :: rng
8554 : end function
8555 : #endif
8556 :
8557 : #if IK4_ENABLED
8558 : impure module function getUnifRandRNGXLU_D1_IK4(rng, lb, ub, s1) result(rand)
8559 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8560 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_IK4
8561 : #endif
8562 : use pm_kind, only: IKC => IK4
8563 : integer(IKC) , intent(in) :: lb, ub
8564 : integer(IK) , intent(in) :: s1
8565 : integer(IKC) :: rand(s1)
8566 : type(xoshiro256ssw_type) , intent(inout) :: rng
8567 : end function
8568 : #endif
8569 :
8570 : #if IK3_ENABLED
8571 : impure module function getUnifRandRNGXLU_D1_IK3(rng, lb, ub, s1) result(rand)
8572 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8573 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_IK3
8574 : #endif
8575 : use pm_kind, only: IKC => IK3
8576 : integer(IKC) , intent(in) :: lb, ub
8577 : integer(IK) , intent(in) :: s1
8578 : integer(IKC) :: rand(s1)
8579 : type(xoshiro256ssw_type) , intent(inout) :: rng
8580 : end function
8581 : #endif
8582 :
8583 : #if IK2_ENABLED
8584 : impure module function getUnifRandRNGXLU_D1_IK2(rng, lb, ub, s1) result(rand)
8585 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8586 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_IK2
8587 : #endif
8588 : use pm_kind, only: IKC => IK2
8589 : integer(IKC) , intent(in) :: lb, ub
8590 : integer(IK) , intent(in) :: s1
8591 : integer(IKC) :: rand(s1)
8592 : type(xoshiro256ssw_type) , intent(inout) :: rng
8593 : end function
8594 : #endif
8595 :
8596 : #if IK1_ENABLED
8597 : impure module function getUnifRandRNGXLU_D1_IK1(rng, lb, ub, s1) result(rand)
8598 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8599 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_IK1
8600 : #endif
8601 : use pm_kind, only: IKC => IK1
8602 : integer(IKC) , intent(in) :: lb, ub
8603 : integer(IK) , intent(in) :: s1
8604 : integer(IKC) :: rand(s1)
8605 : type(xoshiro256ssw_type) , intent(inout) :: rng
8606 : end function
8607 : #endif
8608 :
8609 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8610 :
8611 : #if LK5_ENABLED
8612 : impure module function getUnifRandRNGXLU_D1_LK5(rng, lb, ub, s1) result(rand)
8613 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8614 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_LK5
8615 : #endif
8616 : use pm_kind, only: LKC => LK5
8617 : logical(LKC) , intent(in) :: lb, ub
8618 : integer(IK) , intent(in) :: s1
8619 : logical(LKC) :: rand(s1)
8620 : type(xoshiro256ssw_type) , intent(inout) :: rng
8621 : end function
8622 : #endif
8623 :
8624 : #if LK4_ENABLED
8625 : impure module function getUnifRandRNGXLU_D1_LK4(rng, lb, ub, s1) result(rand)
8626 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8627 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_LK4
8628 : #endif
8629 : use pm_kind, only: LKC => LK4
8630 : logical(LKC) , intent(in) :: lb, ub
8631 : integer(IK) , intent(in) :: s1
8632 : logical(LKC) :: rand(s1)
8633 : type(xoshiro256ssw_type) , intent(inout) :: rng
8634 : end function
8635 : #endif
8636 :
8637 : #if LK3_ENABLED
8638 : impure module function getUnifRandRNGXLU_D1_LK3(rng, lb, ub, s1) result(rand)
8639 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8640 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_LK3
8641 : #endif
8642 : use pm_kind, only: LKC => LK3
8643 : logical(LKC) , intent(in) :: lb, ub
8644 : integer(IK) , intent(in) :: s1
8645 : logical(LKC) :: rand(s1)
8646 : type(xoshiro256ssw_type) , intent(inout) :: rng
8647 : end function
8648 : #endif
8649 :
8650 : #if LK2_ENABLED
8651 : impure module function getUnifRandRNGXLU_D1_LK2(rng, lb, ub, s1) result(rand)
8652 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8653 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_LK2
8654 : #endif
8655 : use pm_kind, only: LKC => LK2
8656 : logical(LKC) , intent(in) :: lb, ub
8657 : integer(IK) , intent(in) :: s1
8658 : logical(LKC) :: rand(s1)
8659 : type(xoshiro256ssw_type) , intent(inout) :: rng
8660 : end function
8661 : #endif
8662 :
8663 : #if LK1_ENABLED
8664 : impure module function getUnifRandRNGXLU_D1_LK1(rng, lb, ub, s1) result(rand)
8665 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8666 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_LK1
8667 : #endif
8668 : use pm_kind, only: LKC => LK1
8669 : logical(LKC) , intent(in) :: lb, ub
8670 : integer(IK) , intent(in) :: s1
8671 : logical(LKC) :: rand(s1)
8672 : type(xoshiro256ssw_type) , intent(inout) :: rng
8673 : end function
8674 : #endif
8675 :
8676 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8677 :
8678 : #if CK5_ENABLED
8679 : impure module function getUnifRandRNGXLU_D1_CK5(rng, lb, ub, s1) result(rand)
8680 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8681 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_CK5
8682 : #endif
8683 : use pm_kind, only: CKC => CK5
8684 : complex(CKC) , intent(in) :: lb, ub
8685 : integer(IK) , intent(in) :: s1
8686 : complex(CKC) :: rand(s1)
8687 : type(xoshiro256ssw_type) , intent(inout) :: rng
8688 : end function
8689 : #endif
8690 :
8691 : #if CK4_ENABLED
8692 : impure module function getUnifRandRNGXLU_D1_CK4(rng, lb, ub, s1) result(rand)
8693 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8694 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_CK4
8695 : #endif
8696 : use pm_kind, only: CKC => CK4
8697 : complex(CKC) , intent(in) :: lb, ub
8698 : integer(IK) , intent(in) :: s1
8699 : complex(CKC) :: rand(s1)
8700 : type(xoshiro256ssw_type) , intent(inout) :: rng
8701 : end function
8702 : #endif
8703 :
8704 : #if CK3_ENABLED
8705 : impure module function getUnifRandRNGXLU_D1_CK3(rng, lb, ub, s1) result(rand)
8706 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8707 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_CK3
8708 : #endif
8709 : use pm_kind, only: CKC => CK3
8710 : complex(CKC) , intent(in) :: lb, ub
8711 : integer(IK) , intent(in) :: s1
8712 : complex(CKC) :: rand(s1)
8713 : type(xoshiro256ssw_type) , intent(inout) :: rng
8714 : end function
8715 : #endif
8716 :
8717 : #if CK2_ENABLED
8718 : impure module function getUnifRandRNGXLU_D1_CK2(rng, lb, ub, s1) result(rand)
8719 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8720 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_CK2
8721 : #endif
8722 : use pm_kind, only: CKC => CK2
8723 : complex(CKC) , intent(in) :: lb, ub
8724 : integer(IK) , intent(in) :: s1
8725 : complex(CKC) :: rand(s1)
8726 : type(xoshiro256ssw_type) , intent(inout) :: rng
8727 : end function
8728 : #endif
8729 :
8730 : #if CK1_ENABLED
8731 : impure module function getUnifRandRNGXLU_D1_CK1(rng, lb, ub, s1) result(rand)
8732 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8733 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_CK1
8734 : #endif
8735 : use pm_kind, only: CKC => CK1
8736 : complex(CKC) , intent(in) :: lb, ub
8737 : integer(IK) , intent(in) :: s1
8738 : complex(CKC) :: rand(s1)
8739 : type(xoshiro256ssw_type) , intent(inout) :: rng
8740 : end function
8741 : #endif
8742 :
8743 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8744 :
8745 : #if RK5_ENABLED
8746 : impure module function getUnifRandRNGXLU_D1_RK5(rng, lb, ub, s1) result(rand)
8747 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8748 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_RK5
8749 : #endif
8750 : use pm_kind, only: RKC => RK5
8751 : real(RKC) , intent(in) :: lb, ub
8752 : integer(IK) , intent(in) :: s1
8753 : real(RKC) :: rand(s1)
8754 : type(xoshiro256ssw_type) , intent(inout) :: rng
8755 : end function
8756 :
8757 : #endif
8758 :
8759 : #if RK4_ENABLED
8760 : impure module function getUnifRandRNGXLU_D1_RK4(rng, lb, ub, s1) result(rand)
8761 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8762 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_RK4
8763 : #endif
8764 : use pm_kind, only: RKC => RK4
8765 : real(RKC) , intent(in) :: lb, ub
8766 : integer(IK) , intent(in) :: s1
8767 : real(RKC) :: rand(s1)
8768 : type(xoshiro256ssw_type) , intent(inout) :: rng
8769 : end function
8770 :
8771 : #endif
8772 :
8773 : #if RK3_ENABLED
8774 : impure module function getUnifRandRNGXLU_D1_RK3(rng, lb, ub, s1) result(rand)
8775 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8776 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_RK3
8777 : #endif
8778 : use pm_kind, only: RKC => RK3
8779 : real(RKC) , intent(in) :: lb, ub
8780 : integer(IK) , intent(in) :: s1
8781 : real(RKC) :: rand(s1)
8782 : type(xoshiro256ssw_type) , intent(inout) :: rng
8783 : end function
8784 :
8785 : #endif
8786 :
8787 : #if RK2_ENABLED
8788 : impure module function getUnifRandRNGXLU_D1_RK2(rng, lb, ub, s1) result(rand)
8789 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8790 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_RK2
8791 : #endif
8792 : use pm_kind, only: RKC => RK2
8793 : real(RKC) , intent(in) :: lb, ub
8794 : integer(IK) , intent(in) :: s1
8795 : real(RKC) :: rand(s1)
8796 : type(xoshiro256ssw_type) , intent(inout) :: rng
8797 : end function
8798 : #endif
8799 :
8800 : #if RK1_ENABLED
8801 : impure module function getUnifRandRNGXLU_D1_RK1(rng, lb, ub, s1) result(rand)
8802 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8803 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D1_RK1
8804 : #endif
8805 : use pm_kind, only: RKC => RK1
8806 : real(RKC) , intent(in) :: lb, ub
8807 : integer(IK) , intent(in) :: s1
8808 : real(RKC) :: rand(s1)
8809 : type(xoshiro256ssw_type) , intent(inout) :: rng
8810 : end function
8811 : #endif
8812 :
8813 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8814 :
8815 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8816 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8817 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8818 :
8819 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8820 :
8821 : #if SK5_ENABLED
8822 : impure module function getUnifRandRNGXLU_D2_SK5(rng, lb, ub, s1, s2) result(rand)
8823 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8824 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_SK5
8825 : #endif
8826 : use pm_kind, only: SKC => SK5
8827 : character(*,SKC) , intent(in) :: lb, ub
8828 : integer(IK) , intent(in) :: s1, s2
8829 : character(len(lb,IK),SKC) :: rand(s1, s2)
8830 : type(xoshiro256ssw_type) , intent(inout) :: rng
8831 : end function
8832 : #endif
8833 :
8834 : #if SK4_ENABLED
8835 : impure module function getUnifRandRNGXLU_D2_SK4(rng, lb, ub, s1, s2) result(rand)
8836 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8837 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_SK4
8838 : #endif
8839 : use pm_kind, only: SKC => SK4
8840 : character(*,SKC) , intent(in) :: lb, ub
8841 : integer(IK) , intent(in) :: s1, s2
8842 : character(len(lb,IK),SKC) :: rand(s1, s2)
8843 : type(xoshiro256ssw_type) , intent(inout) :: rng
8844 : end function
8845 : #endif
8846 :
8847 : #if SK3_ENABLED
8848 : impure module function getUnifRandRNGXLU_D2_SK3(rng, lb, ub, s1, s2) result(rand)
8849 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8850 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_SK3
8851 : #endif
8852 : use pm_kind, only: SKC => SK3
8853 : character(*,SKC) , intent(in) :: lb, ub
8854 : integer(IK) , intent(in) :: s1, s2
8855 : character(len(lb,IK),SKC) :: rand(s1, s2)
8856 : type(xoshiro256ssw_type) , intent(inout) :: rng
8857 : end function
8858 : #endif
8859 :
8860 : #if SK2_ENABLED
8861 : impure module function getUnifRandRNGXLU_D2_SK2(rng, lb, ub, s1, s2) result(rand)
8862 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8863 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_SK2
8864 : #endif
8865 : use pm_kind, only: SKC => SK2
8866 : character(*,SKC) , intent(in) :: lb, ub
8867 : integer(IK) , intent(in) :: s1, s2
8868 : character(len(lb,IK),SKC) :: rand(s1, s2)
8869 : type(xoshiro256ssw_type) , intent(inout) :: rng
8870 : end function
8871 : #endif
8872 :
8873 : #if SK1_ENABLED
8874 : impure module function getUnifRandRNGXLU_D2_SK1(rng, lb, ub, s1, s2) result(rand)
8875 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8876 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_SK1
8877 : #endif
8878 : use pm_kind, only: SKC => SK1
8879 : character(*,SKC) , intent(in) :: lb, ub
8880 : integer(IK) , intent(in) :: s1, s2
8881 : character(len(lb,IK),SKC) :: rand(s1, s2)
8882 : type(xoshiro256ssw_type) , intent(inout) :: rng
8883 : end function
8884 : #endif
8885 :
8886 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8887 :
8888 : #if IK5_ENABLED
8889 : impure module function getUnifRandRNGXLU_D2_IK5(rng, lb, ub, s1, s2) result(rand)
8890 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8891 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_IK5
8892 : #endif
8893 : use pm_kind, only: IKC => IK5
8894 : integer(IKC) , intent(in) :: lb, ub
8895 : integer(IK) , intent(in) :: s1, s2
8896 : integer(IKC) :: rand(s1, s2)
8897 : type(xoshiro256ssw_type) , intent(inout) :: rng
8898 : end function
8899 : #endif
8900 :
8901 : #if IK4_ENABLED
8902 : impure module function getUnifRandRNGXLU_D2_IK4(rng, lb, ub, s1, s2) result(rand)
8903 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8904 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_IK4
8905 : #endif
8906 : use pm_kind, only: IKC => IK4
8907 : integer(IKC) , intent(in) :: lb, ub
8908 : integer(IK) , intent(in) :: s1, s2
8909 : integer(IKC) :: rand(s1, s2)
8910 : type(xoshiro256ssw_type) , intent(inout) :: rng
8911 : end function
8912 : #endif
8913 :
8914 : #if IK3_ENABLED
8915 : impure module function getUnifRandRNGXLU_D2_IK3(rng, lb, ub, s1, s2) result(rand)
8916 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8917 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_IK3
8918 : #endif
8919 : use pm_kind, only: IKC => IK3
8920 : integer(IKC) , intent(in) :: lb, ub
8921 : integer(IK) , intent(in) :: s1, s2
8922 : integer(IKC) :: rand(s1, s2)
8923 : type(xoshiro256ssw_type) , intent(inout) :: rng
8924 : end function
8925 : #endif
8926 :
8927 : #if IK2_ENABLED
8928 : impure module function getUnifRandRNGXLU_D2_IK2(rng, lb, ub, s1, s2) result(rand)
8929 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8930 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_IK2
8931 : #endif
8932 : use pm_kind, only: IKC => IK2
8933 : integer(IKC) , intent(in) :: lb, ub
8934 : integer(IK) , intent(in) :: s1, s2
8935 : integer(IKC) :: rand(s1, s2)
8936 : type(xoshiro256ssw_type) , intent(inout) :: rng
8937 : end function
8938 : #endif
8939 :
8940 : #if IK1_ENABLED
8941 : impure module function getUnifRandRNGXLU_D2_IK1(rng, lb, ub, s1, s2) result(rand)
8942 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8943 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_IK1
8944 : #endif
8945 : use pm_kind, only: IKC => IK1
8946 : integer(IKC) , intent(in) :: lb, ub
8947 : integer(IK) , intent(in) :: s1, s2
8948 : integer(IKC) :: rand(s1, s2)
8949 : type(xoshiro256ssw_type) , intent(inout) :: rng
8950 : end function
8951 : #endif
8952 :
8953 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8954 :
8955 : #if LK5_ENABLED
8956 : impure module function getUnifRandRNGXLU_D2_LK5(rng, lb, ub, s1, s2) result(rand)
8957 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8958 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_LK5
8959 : #endif
8960 : use pm_kind, only: LKC => LK5
8961 : logical(LKC) , intent(in) :: lb, ub
8962 : integer(IK) , intent(in) :: s1, s2
8963 : logical(LKC) :: rand(s1, s2)
8964 : type(xoshiro256ssw_type) , intent(inout) :: rng
8965 : end function
8966 : #endif
8967 :
8968 : #if LK4_ENABLED
8969 : impure module function getUnifRandRNGXLU_D2_LK4(rng, lb, ub, s1, s2) result(rand)
8970 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8971 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_LK4
8972 : #endif
8973 : use pm_kind, only: LKC => LK4
8974 : logical(LKC) , intent(in) :: lb, ub
8975 : integer(IK) , intent(in) :: s1, s2
8976 : logical(LKC) :: rand(s1, s2)
8977 : type(xoshiro256ssw_type) , intent(inout) :: rng
8978 : end function
8979 : #endif
8980 :
8981 : #if LK3_ENABLED
8982 : impure module function getUnifRandRNGXLU_D2_LK3(rng, lb, ub, s1, s2) result(rand)
8983 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8984 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_LK3
8985 : #endif
8986 : use pm_kind, only: LKC => LK3
8987 : logical(LKC) , intent(in) :: lb, ub
8988 : integer(IK) , intent(in) :: s1, s2
8989 : logical(LKC) :: rand(s1, s2)
8990 : type(xoshiro256ssw_type) , intent(inout) :: rng
8991 : end function
8992 : #endif
8993 :
8994 : #if LK2_ENABLED
8995 : impure module function getUnifRandRNGXLU_D2_LK2(rng, lb, ub, s1, s2) result(rand)
8996 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8997 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_LK2
8998 : #endif
8999 : use pm_kind, only: LKC => LK2
9000 : logical(LKC) , intent(in) :: lb, ub
9001 : integer(IK) , intent(in) :: s1, s2
9002 : logical(LKC) :: rand(s1, s2)
9003 : type(xoshiro256ssw_type) , intent(inout) :: rng
9004 : end function
9005 : #endif
9006 :
9007 : #if LK1_ENABLED
9008 : impure module function getUnifRandRNGXLU_D2_LK1(rng, lb, ub, s1, s2) result(rand)
9009 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9010 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_LK1
9011 : #endif
9012 : use pm_kind, only: LKC => LK1
9013 : logical(LKC) , intent(in) :: lb, ub
9014 : integer(IK) , intent(in) :: s1, s2
9015 : logical(LKC) :: rand(s1, s2)
9016 : type(xoshiro256ssw_type) , intent(inout) :: rng
9017 : end function
9018 : #endif
9019 :
9020 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9021 :
9022 : #if CK5_ENABLED
9023 : impure module function getUnifRandRNGXLU_D2_CK5(rng, lb, ub, s1, s2) result(rand)
9024 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9025 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_CK5
9026 : #endif
9027 : use pm_kind, only: CKC => CK5
9028 : complex(CKC) , intent(in) :: lb, ub
9029 : integer(IK) , intent(in) :: s1, s2
9030 : complex(CKC) :: rand(s1, s2)
9031 : type(xoshiro256ssw_type) , intent(inout) :: rng
9032 : end function
9033 : #endif
9034 :
9035 : #if CK4_ENABLED
9036 : impure module function getUnifRandRNGXLU_D2_CK4(rng, lb, ub, s1, s2) result(rand)
9037 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9038 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_CK4
9039 : #endif
9040 : use pm_kind, only: CKC => CK4
9041 : complex(CKC) , intent(in) :: lb, ub
9042 : integer(IK) , intent(in) :: s1, s2
9043 : complex(CKC) :: rand(s1, s2)
9044 : type(xoshiro256ssw_type) , intent(inout) :: rng
9045 : end function
9046 : #endif
9047 :
9048 : #if CK3_ENABLED
9049 : impure module function getUnifRandRNGXLU_D2_CK3(rng, lb, ub, s1, s2) result(rand)
9050 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9051 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_CK3
9052 : #endif
9053 : use pm_kind, only: CKC => CK3
9054 : complex(CKC) , intent(in) :: lb, ub
9055 : integer(IK) , intent(in) :: s1, s2
9056 : complex(CKC) :: rand(s1, s2)
9057 : type(xoshiro256ssw_type) , intent(inout) :: rng
9058 : end function
9059 : #endif
9060 :
9061 : #if CK2_ENABLED
9062 : impure module function getUnifRandRNGXLU_D2_CK2(rng, lb, ub, s1, s2) result(rand)
9063 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9064 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_CK2
9065 : #endif
9066 : use pm_kind, only: CKC => CK2
9067 : complex(CKC) , intent(in) :: lb, ub
9068 : integer(IK) , intent(in) :: s1, s2
9069 : complex(CKC) :: rand(s1, s2)
9070 : type(xoshiro256ssw_type) , intent(inout) :: rng
9071 : end function
9072 : #endif
9073 :
9074 : #if CK1_ENABLED
9075 : impure module function getUnifRandRNGXLU_D2_CK1(rng, lb, ub, s1, s2) result(rand)
9076 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9077 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_CK1
9078 : #endif
9079 : use pm_kind, only: CKC => CK1
9080 : complex(CKC) , intent(in) :: lb, ub
9081 : integer(IK) , intent(in) :: s1, s2
9082 : complex(CKC) :: rand(s1, s2)
9083 : type(xoshiro256ssw_type) , intent(inout) :: rng
9084 : end function
9085 : #endif
9086 :
9087 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9088 :
9089 : #if RK5_ENABLED
9090 : impure module function getUnifRandRNGXLU_D2_RK5(rng, lb, ub, s1, s2) result(rand)
9091 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9092 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_RK5
9093 : #endif
9094 : use pm_kind, only: RKC => RK5
9095 : real(RKC) , intent(in) :: lb, ub
9096 : integer(IK) , intent(in) :: s1, s2
9097 : real(RKC) :: rand(s1, s2)
9098 : type(xoshiro256ssw_type) , intent(inout) :: rng
9099 : end function
9100 :
9101 : #endif
9102 :
9103 : #if RK4_ENABLED
9104 : impure module function getUnifRandRNGXLU_D2_RK4(rng, lb, ub, s1, s2) result(rand)
9105 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9106 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_RK4
9107 : #endif
9108 : use pm_kind, only: RKC => RK4
9109 : real(RKC) , intent(in) :: lb, ub
9110 : integer(IK) , intent(in) :: s1, s2
9111 : real(RKC) :: rand(s1, s2)
9112 : type(xoshiro256ssw_type) , intent(inout) :: rng
9113 : end function
9114 :
9115 : #endif
9116 :
9117 : #if RK3_ENABLED
9118 : impure module function getUnifRandRNGXLU_D2_RK3(rng, lb, ub, s1, s2) result(rand)
9119 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9120 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_RK3
9121 : #endif
9122 : use pm_kind, only: RKC => RK3
9123 : real(RKC) , intent(in) :: lb, ub
9124 : integer(IK) , intent(in) :: s1, s2
9125 : real(RKC) :: rand(s1, s2)
9126 : type(xoshiro256ssw_type) , intent(inout) :: rng
9127 : end function
9128 :
9129 : #endif
9130 :
9131 : #if RK2_ENABLED
9132 : impure module function getUnifRandRNGXLU_D2_RK2(rng, lb, ub, s1, s2) result(rand)
9133 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9134 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_RK2
9135 : #endif
9136 : use pm_kind, only: RKC => RK2
9137 : real(RKC) , intent(in) :: lb, ub
9138 : integer(IK) , intent(in) :: s1, s2
9139 : real(RKC) :: rand(s1, s2)
9140 : type(xoshiro256ssw_type) , intent(inout) :: rng
9141 : end function
9142 : #endif
9143 :
9144 : #if RK1_ENABLED
9145 : impure module function getUnifRandRNGXLU_D2_RK1(rng, lb, ub, s1, s2) result(rand)
9146 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9147 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D2_RK1
9148 : #endif
9149 : use pm_kind, only: RKC => RK1
9150 : real(RKC) , intent(in) :: lb, ub
9151 : integer(IK) , intent(in) :: s1, s2
9152 : real(RKC) :: rand(s1, s2)
9153 : type(xoshiro256ssw_type) , intent(inout) :: rng
9154 : end function
9155 : #endif
9156 :
9157 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9158 :
9159 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9160 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9161 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9162 :
9163 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9164 :
9165 : #if SK5_ENABLED
9166 : impure module function getUnifRandRNGXLU_D3_SK5(rng, lb, ub, s1, s2, s3) result(rand)
9167 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9168 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_SK5
9169 : #endif
9170 : use pm_kind, only: SKC => SK5
9171 : character(*,SKC) , intent(in) :: lb, ub
9172 : integer(IK) , intent(in) :: s1, s2, s3
9173 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
9174 : type(xoshiro256ssw_type) , intent(inout) :: rng
9175 : end function
9176 : #endif
9177 :
9178 : #if SK4_ENABLED
9179 : impure module function getUnifRandRNGXLU_D3_SK4(rng, lb, ub, s1, s2, s3) result(rand)
9180 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9181 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_SK4
9182 : #endif
9183 : use pm_kind, only: SKC => SK4
9184 : character(*,SKC) , intent(in) :: lb, ub
9185 : integer(IK) , intent(in) :: s1, s2, s3
9186 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
9187 : type(xoshiro256ssw_type) , intent(inout) :: rng
9188 : end function
9189 : #endif
9190 :
9191 : #if SK3_ENABLED
9192 : impure module function getUnifRandRNGXLU_D3_SK3(rng, lb, ub, s1, s2, s3) result(rand)
9193 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9194 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_SK3
9195 : #endif
9196 : use pm_kind, only: SKC => SK3
9197 : character(*,SKC) , intent(in) :: lb, ub
9198 : integer(IK) , intent(in) :: s1, s2, s3
9199 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
9200 : type(xoshiro256ssw_type) , intent(inout) :: rng
9201 : end function
9202 : #endif
9203 :
9204 : #if SK2_ENABLED
9205 : impure module function getUnifRandRNGXLU_D3_SK2(rng, lb, ub, s1, s2, s3) result(rand)
9206 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9207 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_SK2
9208 : #endif
9209 : use pm_kind, only: SKC => SK2
9210 : character(*,SKC) , intent(in) :: lb, ub
9211 : integer(IK) , intent(in) :: s1, s2, s3
9212 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
9213 : type(xoshiro256ssw_type) , intent(inout) :: rng
9214 : end function
9215 : #endif
9216 :
9217 : #if SK1_ENABLED
9218 : impure module function getUnifRandRNGXLU_D3_SK1(rng, lb, ub, s1, s2, s3) result(rand)
9219 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9220 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_SK1
9221 : #endif
9222 : use pm_kind, only: SKC => SK1
9223 : character(*,SKC) , intent(in) :: lb, ub
9224 : integer(IK) , intent(in) :: s1, s2, s3
9225 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
9226 : type(xoshiro256ssw_type) , intent(inout) :: rng
9227 : end function
9228 : #endif
9229 :
9230 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9231 :
9232 : #if IK5_ENABLED
9233 : impure module function getUnifRandRNGXLU_D3_IK5(rng, lb, ub, s1, s2, s3) result(rand)
9234 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9235 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_IK5
9236 : #endif
9237 : use pm_kind, only: IKC => IK5
9238 : integer(IKC) , intent(in) :: lb, ub
9239 : integer(IK) , intent(in) :: s1, s2, s3
9240 : integer(IKC) :: rand(s1, s2, s3)
9241 : type(xoshiro256ssw_type) , intent(inout) :: rng
9242 : end function
9243 : #endif
9244 :
9245 : #if IK4_ENABLED
9246 : impure module function getUnifRandRNGXLU_D3_IK4(rng, lb, ub, s1, s2, s3) result(rand)
9247 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9248 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_IK4
9249 : #endif
9250 : use pm_kind, only: IKC => IK4
9251 : integer(IKC) , intent(in) :: lb, ub
9252 : integer(IK) , intent(in) :: s1, s2, s3
9253 : integer(IKC) :: rand(s1, s2, s3)
9254 : type(xoshiro256ssw_type) , intent(inout) :: rng
9255 : end function
9256 : #endif
9257 :
9258 : #if IK3_ENABLED
9259 : impure module function getUnifRandRNGXLU_D3_IK3(rng, lb, ub, s1, s2, s3) result(rand)
9260 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9261 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_IK3
9262 : #endif
9263 : use pm_kind, only: IKC => IK3
9264 : integer(IKC) , intent(in) :: lb, ub
9265 : integer(IK) , intent(in) :: s1, s2, s3
9266 : integer(IKC) :: rand(s1, s2, s3)
9267 : type(xoshiro256ssw_type) , intent(inout) :: rng
9268 : end function
9269 : #endif
9270 :
9271 : #if IK2_ENABLED
9272 : impure module function getUnifRandRNGXLU_D3_IK2(rng, lb, ub, s1, s2, s3) result(rand)
9273 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9274 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_IK2
9275 : #endif
9276 : use pm_kind, only: IKC => IK2
9277 : integer(IKC) , intent(in) :: lb, ub
9278 : integer(IK) , intent(in) :: s1, s2, s3
9279 : integer(IKC) :: rand(s1, s2, s3)
9280 : type(xoshiro256ssw_type) , intent(inout) :: rng
9281 : end function
9282 : #endif
9283 :
9284 : #if IK1_ENABLED
9285 : impure module function getUnifRandRNGXLU_D3_IK1(rng, lb, ub, s1, s2, s3) result(rand)
9286 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9287 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_IK1
9288 : #endif
9289 : use pm_kind, only: IKC => IK1
9290 : integer(IKC) , intent(in) :: lb, ub
9291 : integer(IK) , intent(in) :: s1, s2, s3
9292 : integer(IKC) :: rand(s1, s2, s3)
9293 : type(xoshiro256ssw_type) , intent(inout) :: rng
9294 : end function
9295 : #endif
9296 :
9297 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9298 :
9299 : #if LK5_ENABLED
9300 : impure module function getUnifRandRNGXLU_D3_LK5(rng, lb, ub, s1, s2, s3) result(rand)
9301 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9302 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_LK5
9303 : #endif
9304 : use pm_kind, only: LKC => LK5
9305 : logical(LKC) , intent(in) :: lb, ub
9306 : integer(IK) , intent(in) :: s1, s2, s3
9307 : logical(LKC) :: rand(s1, s2, s3)
9308 : type(xoshiro256ssw_type) , intent(inout) :: rng
9309 : end function
9310 : #endif
9311 :
9312 : #if LK4_ENABLED
9313 : impure module function getUnifRandRNGXLU_D3_LK4(rng, lb, ub, s1, s2, s3) result(rand)
9314 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9315 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_LK4
9316 : #endif
9317 : use pm_kind, only: LKC => LK4
9318 : logical(LKC) , intent(in) :: lb, ub
9319 : integer(IK) , intent(in) :: s1, s2, s3
9320 : logical(LKC) :: rand(s1, s2, s3)
9321 : type(xoshiro256ssw_type) , intent(inout) :: rng
9322 : end function
9323 : #endif
9324 :
9325 : #if LK3_ENABLED
9326 : impure module function getUnifRandRNGXLU_D3_LK3(rng, lb, ub, s1, s2, s3) result(rand)
9327 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9328 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_LK3
9329 : #endif
9330 : use pm_kind, only: LKC => LK3
9331 : logical(LKC) , intent(in) :: lb, ub
9332 : integer(IK) , intent(in) :: s1, s2, s3
9333 : logical(LKC) :: rand(s1, s2, s3)
9334 : type(xoshiro256ssw_type) , intent(inout) :: rng
9335 : end function
9336 : #endif
9337 :
9338 : #if LK2_ENABLED
9339 : impure module function getUnifRandRNGXLU_D3_LK2(rng, lb, ub, s1, s2, s3) result(rand)
9340 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9341 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_LK2
9342 : #endif
9343 : use pm_kind, only: LKC => LK2
9344 : logical(LKC) , intent(in) :: lb, ub
9345 : integer(IK) , intent(in) :: s1, s2, s3
9346 : logical(LKC) :: rand(s1, s2, s3)
9347 : type(xoshiro256ssw_type) , intent(inout) :: rng
9348 : end function
9349 : #endif
9350 :
9351 : #if LK1_ENABLED
9352 : impure module function getUnifRandRNGXLU_D3_LK1(rng, lb, ub, s1, s2, s3) result(rand)
9353 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9354 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_LK1
9355 : #endif
9356 : use pm_kind, only: LKC => LK1
9357 : logical(LKC) , intent(in) :: lb, ub
9358 : integer(IK) , intent(in) :: s1, s2, s3
9359 : logical(LKC) :: rand(s1, s2, s3)
9360 : type(xoshiro256ssw_type) , intent(inout) :: rng
9361 : end function
9362 : #endif
9363 :
9364 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9365 :
9366 : #if CK5_ENABLED
9367 : impure module function getUnifRandRNGXLU_D3_CK5(rng, lb, ub, s1, s2, s3) result(rand)
9368 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9369 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_CK5
9370 : #endif
9371 : use pm_kind, only: CKC => CK5
9372 : complex(CKC) , intent(in) :: lb, ub
9373 : integer(IK) , intent(in) :: s1, s2, s3
9374 : complex(CKC) :: rand(s1, s2, s3)
9375 : type(xoshiro256ssw_type) , intent(inout) :: rng
9376 : end function
9377 : #endif
9378 :
9379 : #if CK4_ENABLED
9380 : impure module function getUnifRandRNGXLU_D3_CK4(rng, lb, ub, s1, s2, s3) result(rand)
9381 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9382 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_CK4
9383 : #endif
9384 : use pm_kind, only: CKC => CK4
9385 : complex(CKC) , intent(in) :: lb, ub
9386 : integer(IK) , intent(in) :: s1, s2, s3
9387 : complex(CKC) :: rand(s1, s2, s3)
9388 : type(xoshiro256ssw_type) , intent(inout) :: rng
9389 : end function
9390 : #endif
9391 :
9392 : #if CK3_ENABLED
9393 : impure module function getUnifRandRNGXLU_D3_CK3(rng, lb, ub, s1, s2, s3) result(rand)
9394 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9395 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_CK3
9396 : #endif
9397 : use pm_kind, only: CKC => CK3
9398 : complex(CKC) , intent(in) :: lb, ub
9399 : integer(IK) , intent(in) :: s1, s2, s3
9400 : complex(CKC) :: rand(s1, s2, s3)
9401 : type(xoshiro256ssw_type) , intent(inout) :: rng
9402 : end function
9403 : #endif
9404 :
9405 : #if CK2_ENABLED
9406 : impure module function getUnifRandRNGXLU_D3_CK2(rng, lb, ub, s1, s2, s3) result(rand)
9407 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9408 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_CK2
9409 : #endif
9410 : use pm_kind, only: CKC => CK2
9411 : complex(CKC) , intent(in) :: lb, ub
9412 : integer(IK) , intent(in) :: s1, s2, s3
9413 : complex(CKC) :: rand(s1, s2, s3)
9414 : type(xoshiro256ssw_type) , intent(inout) :: rng
9415 : end function
9416 : #endif
9417 :
9418 : #if CK1_ENABLED
9419 : impure module function getUnifRandRNGXLU_D3_CK1(rng, lb, ub, s1, s2, s3) result(rand)
9420 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9421 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_CK1
9422 : #endif
9423 : use pm_kind, only: CKC => CK1
9424 : complex(CKC) , intent(in) :: lb, ub
9425 : integer(IK) , intent(in) :: s1, s2, s3
9426 : complex(CKC) :: rand(s1, s2, s3)
9427 : type(xoshiro256ssw_type) , intent(inout) :: rng
9428 : end function
9429 : #endif
9430 :
9431 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9432 :
9433 : #if RK5_ENABLED
9434 : impure module function getUnifRandRNGXLU_D3_RK5(rng, lb, ub, s1, s2, s3) result(rand)
9435 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9436 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_RK5
9437 : #endif
9438 : use pm_kind, only: RKC => RK5
9439 : real(RKC) , intent(in) :: lb, ub
9440 : integer(IK) , intent(in) :: s1, s2, s3
9441 : real(RKC) :: rand(s1, s2, s3)
9442 : type(xoshiro256ssw_type) , intent(inout) :: rng
9443 : end function
9444 :
9445 : #endif
9446 :
9447 : #if RK4_ENABLED
9448 : impure module function getUnifRandRNGXLU_D3_RK4(rng, lb, ub, s1, s2, s3) result(rand)
9449 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9450 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_RK4
9451 : #endif
9452 : use pm_kind, only: RKC => RK4
9453 : real(RKC) , intent(in) :: lb, ub
9454 : integer(IK) , intent(in) :: s1, s2, s3
9455 : real(RKC) :: rand(s1, s2, s3)
9456 : type(xoshiro256ssw_type) , intent(inout) :: rng
9457 : end function
9458 :
9459 : #endif
9460 :
9461 : #if RK3_ENABLED
9462 : impure module function getUnifRandRNGXLU_D3_RK3(rng, lb, ub, s1, s2, s3) result(rand)
9463 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9464 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_RK3
9465 : #endif
9466 : use pm_kind, only: RKC => RK3
9467 : real(RKC) , intent(in) :: lb, ub
9468 : integer(IK) , intent(in) :: s1, s2, s3
9469 : real(RKC) :: rand(s1, s2, s3)
9470 : type(xoshiro256ssw_type) , intent(inout) :: rng
9471 : end function
9472 :
9473 : #endif
9474 :
9475 : #if RK2_ENABLED
9476 : impure module function getUnifRandRNGXLU_D3_RK2(rng, lb, ub, s1, s2, s3) result(rand)
9477 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9478 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_RK2
9479 : #endif
9480 : use pm_kind, only: RKC => RK2
9481 : real(RKC) , intent(in) :: lb, ub
9482 : integer(IK) , intent(in) :: s1, s2, s3
9483 : real(RKC) :: rand(s1, s2, s3)
9484 : type(xoshiro256ssw_type) , intent(inout) :: rng
9485 : end function
9486 : #endif
9487 :
9488 : #if RK1_ENABLED
9489 : impure module function getUnifRandRNGXLU_D3_RK1(rng, lb, ub, s1, s2, s3) result(rand)
9490 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9491 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGXLU_D3_RK1
9492 : #endif
9493 : use pm_kind, only: RKC => RK1
9494 : real(RKC) , intent(in) :: lb, ub
9495 : integer(IK) , intent(in) :: s1, s2, s3
9496 : real(RKC) :: rand(s1, s2, s3)
9497 : type(xoshiro256ssw_type) , intent(inout) :: rng
9498 : end function
9499 : #endif
9500 :
9501 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9502 :
9503 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9504 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9505 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9506 :
9507 : end interface
9508 :
9509 : ! RNGG
9510 :
9511 : interface getUnifRand
9512 :
9513 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9514 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9515 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9516 :
9517 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9518 :
9519 : impure module function getUnifRandRNGGDD_D0_LK(rng) result(rand)
9520 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9521 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGDD_D0_LK
9522 : #endif
9523 : use pm_kind, only: LKC => LK
9524 : logical(LKC) :: rand
9525 : type(xoshiro256ssg_type) , intent(inout) :: rng
9526 : end function
9527 :
9528 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9529 :
9530 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9531 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9532 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9533 :
9534 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9535 :
9536 : #if SK5_ENABLED
9537 : impure elemental module function getUnifRandRNGGLU_D0_SK5(rng, lb, ub) result(rand)
9538 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9539 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_SK5
9540 : #endif
9541 : use pm_kind, only: SKC => SK5
9542 : character(*,SKC) , intent(in) :: lb, ub
9543 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
9544 : type(xoshiro256ssg_type) , intent(inout) :: rng
9545 : end function
9546 : #endif
9547 :
9548 : #if SK4_ENABLED
9549 : impure elemental module function getUnifRandRNGGLU_D0_SK4(rng, lb, ub) result(rand)
9550 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9551 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_SK4
9552 : #endif
9553 : use pm_kind, only: SKC => SK4
9554 : character(*,SKC) , intent(in) :: lb, ub
9555 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
9556 : type(xoshiro256ssg_type) , intent(inout) :: rng
9557 : end function
9558 : #endif
9559 :
9560 : #if SK3_ENABLED
9561 : impure elemental module function getUnifRandRNGGLU_D0_SK3(rng, lb, ub) result(rand)
9562 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9563 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_SK3
9564 : #endif
9565 : use pm_kind, only: SKC => SK3
9566 : character(*,SKC) , intent(in) :: lb, ub
9567 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
9568 : type(xoshiro256ssg_type) , intent(inout) :: rng
9569 : end function
9570 : #endif
9571 :
9572 : #if SK2_ENABLED
9573 : impure elemental module function getUnifRandRNGGLU_D0_SK2(rng, lb, ub) result(rand)
9574 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9575 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_SK2
9576 : #endif
9577 : use pm_kind, only: SKC => SK2
9578 : character(*,SKC) , intent(in) :: lb, ub
9579 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
9580 : type(xoshiro256ssg_type) , intent(inout) :: rng
9581 : end function
9582 : #endif
9583 :
9584 : #if SK1_ENABLED
9585 : impure elemental module function getUnifRandRNGGLU_D0_SK1(rng, lb, ub) result(rand)
9586 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9587 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_SK1
9588 : #endif
9589 : use pm_kind, only: SKC => SK1
9590 : character(*,SKC) , intent(in) :: lb, ub
9591 : character(max(len(lb,IK),len(ub,IK)),SKC) :: rand
9592 : type(xoshiro256ssg_type) , intent(inout) :: rng
9593 : end function
9594 : #endif
9595 :
9596 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9597 :
9598 : #if IK5_ENABLED
9599 : impure elemental module function getUnifRandRNGGLU_D0_IK5(rng, lb, ub) result(rand)
9600 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9601 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_IK5
9602 : #endif
9603 : use pm_kind, only: IKC => IK5
9604 : integer(IKC) , intent(in) :: lb, ub
9605 : integer(IKC) :: rand
9606 : type(xoshiro256ssg_type) , intent(inout) :: rng
9607 : end function
9608 : #endif
9609 :
9610 : #if IK4_ENABLED
9611 : impure elemental module function getUnifRandRNGGLU_D0_IK4(rng, lb, ub) result(rand)
9612 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9613 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_IK4
9614 : #endif
9615 : use pm_kind, only: IKC => IK4
9616 : integer(IKC) , intent(in) :: lb, ub
9617 : integer(IKC) :: rand
9618 : type(xoshiro256ssg_type) , intent(inout) :: rng
9619 : end function
9620 : #endif
9621 :
9622 : #if IK3_ENABLED
9623 : impure elemental module function getUnifRandRNGGLU_D0_IK3(rng, lb, ub) result(rand)
9624 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9625 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_IK3
9626 : #endif
9627 : use pm_kind, only: IKC => IK3
9628 : integer(IKC) , intent(in) :: lb, ub
9629 : integer(IKC) :: rand
9630 : type(xoshiro256ssg_type) , intent(inout) :: rng
9631 : end function
9632 : #endif
9633 :
9634 : #if IK2_ENABLED
9635 : impure elemental module function getUnifRandRNGGLU_D0_IK2(rng, lb, ub) result(rand)
9636 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9637 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_IK2
9638 : #endif
9639 : use pm_kind, only: IKC => IK2
9640 : integer(IKC) , intent(in) :: lb, ub
9641 : integer(IKC) :: rand
9642 : type(xoshiro256ssg_type) , intent(inout) :: rng
9643 : end function
9644 : #endif
9645 :
9646 : #if IK1_ENABLED
9647 : impure elemental module function getUnifRandRNGGLU_D0_IK1(rng, lb, ub) result(rand)
9648 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9649 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_IK1
9650 : #endif
9651 : use pm_kind, only: IKC => IK1
9652 : integer(IKC) , intent(in) :: lb, ub
9653 : integer(IKC) :: rand
9654 : type(xoshiro256ssg_type) , intent(inout) :: rng
9655 : end function
9656 : #endif
9657 :
9658 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9659 :
9660 : #if LK5_ENABLED
9661 : impure elemental module function getUnifRandRNGGLU_D0_LK5(rng, lb, ub) result(rand)
9662 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9663 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_LK5
9664 : #endif
9665 : use pm_kind, only: LKC => LK5
9666 : logical(LKC) , intent(in) :: lb, ub
9667 : logical(LKC) :: rand
9668 : type(xoshiro256ssg_type) , intent(inout) :: rng
9669 : end function
9670 : #endif
9671 :
9672 : #if LK4_ENABLED
9673 : impure elemental module function getUnifRandRNGGLU_D0_LK4(rng, lb, ub) result(rand)
9674 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9675 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_LK4
9676 : #endif
9677 : use pm_kind, only: LKC => LK4
9678 : logical(LKC) , intent(in) :: lb, ub
9679 : logical(LKC) :: rand
9680 : type(xoshiro256ssg_type) , intent(inout) :: rng
9681 : end function
9682 : #endif
9683 :
9684 : #if LK3_ENABLED
9685 : impure elemental module function getUnifRandRNGGLU_D0_LK3(rng, lb, ub) result(rand)
9686 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9687 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_LK3
9688 : #endif
9689 : use pm_kind, only: LKC => LK3
9690 : logical(LKC) , intent(in) :: lb, ub
9691 : logical(LKC) :: rand
9692 : type(xoshiro256ssg_type) , intent(inout) :: rng
9693 : end function
9694 : #endif
9695 :
9696 : #if LK2_ENABLED
9697 : impure elemental module function getUnifRandRNGGLU_D0_LK2(rng, lb, ub) result(rand)
9698 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9699 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_LK2
9700 : #endif
9701 : use pm_kind, only: LKC => LK2
9702 : logical(LKC) , intent(in) :: lb, ub
9703 : logical(LKC) :: rand
9704 : type(xoshiro256ssg_type) , intent(inout) :: rng
9705 : end function
9706 : #endif
9707 :
9708 : #if LK1_ENABLED
9709 : impure elemental module function getUnifRandRNGGLU_D0_LK1(rng, lb, ub) result(rand)
9710 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9711 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_LK1
9712 : #endif
9713 : use pm_kind, only: LKC => LK1
9714 : logical(LKC) , intent(in) :: lb, ub
9715 : logical(LKC) :: rand
9716 : type(xoshiro256ssg_type) , intent(inout) :: rng
9717 : end function
9718 : #endif
9719 :
9720 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9721 :
9722 : #if CK5_ENABLED
9723 : impure elemental module function getUnifRandRNGGLU_D0_CK5(rng, lb, ub) result(rand)
9724 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9725 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_CK5
9726 : #endif
9727 : use pm_kind, only: CKC => CK5
9728 : complex(CKC) , intent(in) :: lb, ub
9729 : complex(CKC) :: rand
9730 : type(xoshiro256ssg_type) , intent(inout) :: rng
9731 : end function
9732 : #endif
9733 :
9734 : #if CK4_ENABLED
9735 : impure elemental module function getUnifRandRNGGLU_D0_CK4(rng, lb, ub) result(rand)
9736 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9737 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_CK4
9738 : #endif
9739 : use pm_kind, only: CKC => CK4
9740 : complex(CKC) , intent(in) :: lb, ub
9741 : complex(CKC) :: rand
9742 : type(xoshiro256ssg_type) , intent(inout) :: rng
9743 : end function
9744 : #endif
9745 :
9746 : #if CK3_ENABLED
9747 : impure elemental module function getUnifRandRNGGLU_D0_CK3(rng, lb, ub) result(rand)
9748 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9749 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_CK3
9750 : #endif
9751 : use pm_kind, only: CKC => CK3
9752 : complex(CKC) , intent(in) :: lb, ub
9753 : complex(CKC) :: rand
9754 : type(xoshiro256ssg_type) , intent(inout) :: rng
9755 : end function
9756 : #endif
9757 :
9758 : #if CK2_ENABLED
9759 : impure elemental module function getUnifRandRNGGLU_D0_CK2(rng, lb, ub) result(rand)
9760 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9761 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_CK2
9762 : #endif
9763 : use pm_kind, only: CKC => CK2
9764 : complex(CKC) , intent(in) :: lb, ub
9765 : complex(CKC) :: rand
9766 : type(xoshiro256ssg_type) , intent(inout) :: rng
9767 : end function
9768 : #endif
9769 :
9770 : #if CK1_ENABLED
9771 : impure elemental module function getUnifRandRNGGLU_D0_CK1(rng, lb, ub) result(rand)
9772 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9773 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_CK1
9774 : #endif
9775 : use pm_kind, only: CKC => CK1
9776 : complex(CKC) , intent(in) :: lb, ub
9777 : complex(CKC) :: rand
9778 : type(xoshiro256ssg_type) , intent(inout) :: rng
9779 : end function
9780 : #endif
9781 :
9782 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9783 :
9784 : #if RK5_ENABLED
9785 : impure elemental module function getUnifRandRNGGLU_D0_RK5(rng, lb, ub) result(rand)
9786 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9787 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_RK5
9788 : #endif
9789 : use pm_kind, only: RKC => RK5
9790 : real(RKC) , intent(in) :: lb, ub
9791 : real(RKC) :: rand
9792 : type(xoshiro256ssg_type) , intent(inout) :: rng
9793 : end function
9794 : #endif
9795 :
9796 : #if RK4_ENABLED
9797 : impure elemental module function getUnifRandRNGGLU_D0_RK4(rng, lb, ub) result(rand)
9798 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9799 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_RK4
9800 : #endif
9801 : use pm_kind, only: RKC => RK4
9802 : real(RKC) , intent(in) :: lb, ub
9803 : real(RKC) :: rand
9804 : type(xoshiro256ssg_type) , intent(inout) :: rng
9805 : end function
9806 : #endif
9807 :
9808 : #if RK3_ENABLED
9809 : impure elemental module function getUnifRandRNGGLU_D0_RK3(rng, lb, ub) result(rand)
9810 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9811 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_RK3
9812 : #endif
9813 : use pm_kind, only: RKC => RK3
9814 : real(RKC) , intent(in) :: lb, ub
9815 : real(RKC) :: rand
9816 : type(xoshiro256ssg_type) , intent(inout) :: rng
9817 : end function
9818 : #endif
9819 :
9820 : #if RK2_ENABLED
9821 : impure elemental module function getUnifRandRNGGLU_D0_RK2(rng, lb, ub) result(rand)
9822 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9823 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_RK2
9824 : #endif
9825 : use pm_kind, only: RKC => RK2
9826 : real(RKC) , intent(in) :: lb, ub
9827 : real(RKC) :: rand
9828 : type(xoshiro256ssg_type) , intent(inout) :: rng
9829 : end function
9830 : #endif
9831 :
9832 : #if RK1_ENABLED
9833 : impure elemental module function getUnifRandRNGGLU_D0_RK1(rng, lb, ub) result(rand)
9834 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9835 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D0_RK1
9836 : #endif
9837 : use pm_kind, only: RKC => RK1
9838 : real(RKC) , intent(in) :: lb, ub
9839 : real(RKC) :: rand
9840 : type(xoshiro256ssg_type) , intent(inout) :: rng
9841 : end function
9842 : #endif
9843 :
9844 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9845 :
9846 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9847 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9848 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9849 :
9850 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9851 :
9852 : #if SK5_ENABLED
9853 : impure module function getUnifRandRNGGLU_D1_SK5(rng, lb, ub, s1) result(rand)
9854 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9855 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_SK5
9856 : #endif
9857 : use pm_kind, only: SKC => SK5
9858 : character(*,SKC) , intent(in) :: lb, ub
9859 : integer(IK) , intent(in) :: s1
9860 : character(len(lb,IK),SKC) :: rand(s1)
9861 : type(xoshiro256ssg_type) , intent(inout) :: rng
9862 : end function
9863 : #endif
9864 :
9865 : #if SK4_ENABLED
9866 : impure module function getUnifRandRNGGLU_D1_SK4(rng, lb, ub, s1) result(rand)
9867 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9868 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_SK4
9869 : #endif
9870 : use pm_kind, only: SKC => SK4
9871 : character(*,SKC) , intent(in) :: lb, ub
9872 : integer(IK) , intent(in) :: s1
9873 : character(len(lb,IK),SKC) :: rand(s1)
9874 : type(xoshiro256ssg_type) , intent(inout) :: rng
9875 : end function
9876 : #endif
9877 :
9878 : #if SK3_ENABLED
9879 : impure module function getUnifRandRNGGLU_D1_SK3(rng, lb, ub, s1) result(rand)
9880 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9881 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_SK3
9882 : #endif
9883 : use pm_kind, only: SKC => SK3
9884 : character(*,SKC) , intent(in) :: lb, ub
9885 : integer(IK) , intent(in) :: s1
9886 : character(len(lb,IK),SKC) :: rand(s1)
9887 : type(xoshiro256ssg_type) , intent(inout) :: rng
9888 : end function
9889 : #endif
9890 :
9891 : #if SK2_ENABLED
9892 : impure module function getUnifRandRNGGLU_D1_SK2(rng, lb, ub, s1) result(rand)
9893 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9894 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_SK2
9895 : #endif
9896 : use pm_kind, only: SKC => SK2
9897 : character(*,SKC) , intent(in) :: lb, ub
9898 : integer(IK) , intent(in) :: s1
9899 : character(len(lb,IK),SKC) :: rand(s1)
9900 : type(xoshiro256ssg_type) , intent(inout) :: rng
9901 : end function
9902 : #endif
9903 :
9904 : #if SK1_ENABLED
9905 : impure module function getUnifRandRNGGLU_D1_SK1(rng, lb, ub, s1) result(rand)
9906 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9907 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_SK1
9908 : #endif
9909 : use pm_kind, only: SKC => SK1
9910 : character(*,SKC) , intent(in) :: lb, ub
9911 : integer(IK) , intent(in) :: s1
9912 : character(len(lb,IK),SKC) :: rand(s1)
9913 : type(xoshiro256ssg_type) , intent(inout) :: rng
9914 : end function
9915 : #endif
9916 :
9917 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9918 :
9919 : #if IK5_ENABLED
9920 : impure module function getUnifRandRNGGLU_D1_IK5(rng, lb, ub, s1) result(rand)
9921 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9922 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_IK5
9923 : #endif
9924 : use pm_kind, only: IKC => IK5
9925 : integer(IKC) , intent(in) :: lb, ub
9926 : integer(IK) , intent(in) :: s1
9927 : integer(IKC) :: rand(s1)
9928 : type(xoshiro256ssg_type) , intent(inout) :: rng
9929 : end function
9930 : #endif
9931 :
9932 : #if IK4_ENABLED
9933 : impure module function getUnifRandRNGGLU_D1_IK4(rng, lb, ub, s1) result(rand)
9934 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9935 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_IK4
9936 : #endif
9937 : use pm_kind, only: IKC => IK4
9938 : integer(IKC) , intent(in) :: lb, ub
9939 : integer(IK) , intent(in) :: s1
9940 : integer(IKC) :: rand(s1)
9941 : type(xoshiro256ssg_type) , intent(inout) :: rng
9942 : end function
9943 : #endif
9944 :
9945 : #if IK3_ENABLED
9946 : impure module function getUnifRandRNGGLU_D1_IK3(rng, lb, ub, s1) result(rand)
9947 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9948 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_IK3
9949 : #endif
9950 : use pm_kind, only: IKC => IK3
9951 : integer(IKC) , intent(in) :: lb, ub
9952 : integer(IK) , intent(in) :: s1
9953 : integer(IKC) :: rand(s1)
9954 : type(xoshiro256ssg_type) , intent(inout) :: rng
9955 : end function
9956 : #endif
9957 :
9958 : #if IK2_ENABLED
9959 : impure module function getUnifRandRNGGLU_D1_IK2(rng, lb, ub, s1) result(rand)
9960 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9961 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_IK2
9962 : #endif
9963 : use pm_kind, only: IKC => IK2
9964 : integer(IKC) , intent(in) :: lb, ub
9965 : integer(IK) , intent(in) :: s1
9966 : integer(IKC) :: rand(s1)
9967 : type(xoshiro256ssg_type) , intent(inout) :: rng
9968 : end function
9969 : #endif
9970 :
9971 : #if IK1_ENABLED
9972 : impure module function getUnifRandRNGGLU_D1_IK1(rng, lb, ub, s1) result(rand)
9973 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9974 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_IK1
9975 : #endif
9976 : use pm_kind, only: IKC => IK1
9977 : integer(IKC) , intent(in) :: lb, ub
9978 : integer(IK) , intent(in) :: s1
9979 : integer(IKC) :: rand(s1)
9980 : type(xoshiro256ssg_type) , intent(inout) :: rng
9981 : end function
9982 : #endif
9983 :
9984 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9985 :
9986 : #if LK5_ENABLED
9987 : impure module function getUnifRandRNGGLU_D1_LK5(rng, lb, ub, s1) result(rand)
9988 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9989 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_LK5
9990 : #endif
9991 : use pm_kind, only: LKC => LK5
9992 : logical(LKC) , intent(in) :: lb, ub
9993 : integer(IK) , intent(in) :: s1
9994 : logical(LKC) :: rand(s1)
9995 : type(xoshiro256ssg_type) , intent(inout) :: rng
9996 : end function
9997 : #endif
9998 :
9999 : #if LK4_ENABLED
10000 : impure module function getUnifRandRNGGLU_D1_LK4(rng, lb, ub, s1) result(rand)
10001 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10002 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_LK4
10003 : #endif
10004 : use pm_kind, only: LKC => LK4
10005 : logical(LKC) , intent(in) :: lb, ub
10006 : integer(IK) , intent(in) :: s1
10007 : logical(LKC) :: rand(s1)
10008 : type(xoshiro256ssg_type) , intent(inout) :: rng
10009 : end function
10010 : #endif
10011 :
10012 : #if LK3_ENABLED
10013 : impure module function getUnifRandRNGGLU_D1_LK3(rng, lb, ub, s1) result(rand)
10014 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10015 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_LK3
10016 : #endif
10017 : use pm_kind, only: LKC => LK3
10018 : logical(LKC) , intent(in) :: lb, ub
10019 : integer(IK) , intent(in) :: s1
10020 : logical(LKC) :: rand(s1)
10021 : type(xoshiro256ssg_type) , intent(inout) :: rng
10022 : end function
10023 : #endif
10024 :
10025 : #if LK2_ENABLED
10026 : impure module function getUnifRandRNGGLU_D1_LK2(rng, lb, ub, s1) result(rand)
10027 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10028 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_LK2
10029 : #endif
10030 : use pm_kind, only: LKC => LK2
10031 : logical(LKC) , intent(in) :: lb, ub
10032 : integer(IK) , intent(in) :: s1
10033 : logical(LKC) :: rand(s1)
10034 : type(xoshiro256ssg_type) , intent(inout) :: rng
10035 : end function
10036 : #endif
10037 :
10038 : #if LK1_ENABLED
10039 : impure module function getUnifRandRNGGLU_D1_LK1(rng, lb, ub, s1) result(rand)
10040 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10041 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_LK1
10042 : #endif
10043 : use pm_kind, only: LKC => LK1
10044 : logical(LKC) , intent(in) :: lb, ub
10045 : integer(IK) , intent(in) :: s1
10046 : logical(LKC) :: rand(s1)
10047 : type(xoshiro256ssg_type) , intent(inout) :: rng
10048 : end function
10049 : #endif
10050 :
10051 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10052 :
10053 : #if CK5_ENABLED
10054 : impure module function getUnifRandRNGGLU_D1_CK5(rng, lb, ub, s1) result(rand)
10055 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10056 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_CK5
10057 : #endif
10058 : use pm_kind, only: CKC => CK5
10059 : complex(CKC) , intent(in) :: lb, ub
10060 : integer(IK) , intent(in) :: s1
10061 : complex(CKC) :: rand(s1)
10062 : type(xoshiro256ssg_type) , intent(inout) :: rng
10063 : end function
10064 : #endif
10065 :
10066 : #if CK4_ENABLED
10067 : impure module function getUnifRandRNGGLU_D1_CK4(rng, lb, ub, s1) result(rand)
10068 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10069 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_CK4
10070 : #endif
10071 : use pm_kind, only: CKC => CK4
10072 : complex(CKC) , intent(in) :: lb, ub
10073 : integer(IK) , intent(in) :: s1
10074 : complex(CKC) :: rand(s1)
10075 : type(xoshiro256ssg_type) , intent(inout) :: rng
10076 : end function
10077 : #endif
10078 :
10079 : #if CK3_ENABLED
10080 : impure module function getUnifRandRNGGLU_D1_CK3(rng, lb, ub, s1) result(rand)
10081 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10082 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_CK3
10083 : #endif
10084 : use pm_kind, only: CKC => CK3
10085 : complex(CKC) , intent(in) :: lb, ub
10086 : integer(IK) , intent(in) :: s1
10087 : complex(CKC) :: rand(s1)
10088 : type(xoshiro256ssg_type) , intent(inout) :: rng
10089 : end function
10090 : #endif
10091 :
10092 : #if CK2_ENABLED
10093 : impure module function getUnifRandRNGGLU_D1_CK2(rng, lb, ub, s1) result(rand)
10094 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10095 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_CK2
10096 : #endif
10097 : use pm_kind, only: CKC => CK2
10098 : complex(CKC) , intent(in) :: lb, ub
10099 : integer(IK) , intent(in) :: s1
10100 : complex(CKC) :: rand(s1)
10101 : type(xoshiro256ssg_type) , intent(inout) :: rng
10102 : end function
10103 : #endif
10104 :
10105 : #if CK1_ENABLED
10106 : impure module function getUnifRandRNGGLU_D1_CK1(rng, lb, ub, s1) result(rand)
10107 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10108 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_CK1
10109 : #endif
10110 : use pm_kind, only: CKC => CK1
10111 : complex(CKC) , intent(in) :: lb, ub
10112 : integer(IK) , intent(in) :: s1
10113 : complex(CKC) :: rand(s1)
10114 : type(xoshiro256ssg_type) , intent(inout) :: rng
10115 : end function
10116 : #endif
10117 :
10118 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10119 :
10120 : #if RK5_ENABLED
10121 : impure module function getUnifRandRNGGLU_D1_RK5(rng, lb, ub, s1) result(rand)
10122 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10123 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_RK5
10124 : #endif
10125 : use pm_kind, only: RKC => RK5
10126 : real(RKC) , intent(in) :: lb, ub
10127 : integer(IK) , intent(in) :: s1
10128 : real(RKC) :: rand(s1)
10129 : type(xoshiro256ssg_type) , intent(inout) :: rng
10130 : end function
10131 :
10132 : #endif
10133 :
10134 : #if RK4_ENABLED
10135 : impure module function getUnifRandRNGGLU_D1_RK4(rng, lb, ub, s1) result(rand)
10136 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10137 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_RK4
10138 : #endif
10139 : use pm_kind, only: RKC => RK4
10140 : real(RKC) , intent(in) :: lb, ub
10141 : integer(IK) , intent(in) :: s1
10142 : real(RKC) :: rand(s1)
10143 : type(xoshiro256ssg_type) , intent(inout) :: rng
10144 : end function
10145 :
10146 : #endif
10147 :
10148 : #if RK3_ENABLED
10149 : impure module function getUnifRandRNGGLU_D1_RK3(rng, lb, ub, s1) result(rand)
10150 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10151 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_RK3
10152 : #endif
10153 : use pm_kind, only: RKC => RK3
10154 : real(RKC) , intent(in) :: lb, ub
10155 : integer(IK) , intent(in) :: s1
10156 : real(RKC) :: rand(s1)
10157 : type(xoshiro256ssg_type) , intent(inout) :: rng
10158 : end function
10159 :
10160 : #endif
10161 :
10162 : #if RK2_ENABLED
10163 : impure module function getUnifRandRNGGLU_D1_RK2(rng, lb, ub, s1) result(rand)
10164 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10165 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_RK2
10166 : #endif
10167 : use pm_kind, only: RKC => RK2
10168 : real(RKC) , intent(in) :: lb, ub
10169 : integer(IK) , intent(in) :: s1
10170 : real(RKC) :: rand(s1)
10171 : type(xoshiro256ssg_type) , intent(inout) :: rng
10172 : end function
10173 : #endif
10174 :
10175 : #if RK1_ENABLED
10176 : impure module function getUnifRandRNGGLU_D1_RK1(rng, lb, ub, s1) result(rand)
10177 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10178 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D1_RK1
10179 : #endif
10180 : use pm_kind, only: RKC => RK1
10181 : real(RKC) , intent(in) :: lb, ub
10182 : integer(IK) , intent(in) :: s1
10183 : real(RKC) :: rand(s1)
10184 : type(xoshiro256ssg_type) , intent(inout) :: rng
10185 : end function
10186 : #endif
10187 :
10188 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10189 :
10190 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10191 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10192 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10193 :
10194 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10195 :
10196 : #if SK5_ENABLED
10197 : impure module function getUnifRandRNGGLU_D2_SK5(rng, lb, ub, s1, s2) result(rand)
10198 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10199 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_SK5
10200 : #endif
10201 : use pm_kind, only: SKC => SK5
10202 : character(*,SKC) , intent(in) :: lb, ub
10203 : integer(IK) , intent(in) :: s1, s2
10204 : character(len(lb,IK),SKC) :: rand(s1, s2)
10205 : type(xoshiro256ssg_type) , intent(inout) :: rng
10206 : end function
10207 : #endif
10208 :
10209 : #if SK4_ENABLED
10210 : impure module function getUnifRandRNGGLU_D2_SK4(rng, lb, ub, s1, s2) result(rand)
10211 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10212 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_SK4
10213 : #endif
10214 : use pm_kind, only: SKC => SK4
10215 : character(*,SKC) , intent(in) :: lb, ub
10216 : integer(IK) , intent(in) :: s1, s2
10217 : character(len(lb,IK),SKC) :: rand(s1, s2)
10218 : type(xoshiro256ssg_type) , intent(inout) :: rng
10219 : end function
10220 : #endif
10221 :
10222 : #if SK3_ENABLED
10223 : impure module function getUnifRandRNGGLU_D2_SK3(rng, lb, ub, s1, s2) result(rand)
10224 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10225 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_SK3
10226 : #endif
10227 : use pm_kind, only: SKC => SK3
10228 : character(*,SKC) , intent(in) :: lb, ub
10229 : integer(IK) , intent(in) :: s1, s2
10230 : character(len(lb,IK),SKC) :: rand(s1, s2)
10231 : type(xoshiro256ssg_type) , intent(inout) :: rng
10232 : end function
10233 : #endif
10234 :
10235 : #if SK2_ENABLED
10236 : impure module function getUnifRandRNGGLU_D2_SK2(rng, lb, ub, s1, s2) result(rand)
10237 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10238 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_SK2
10239 : #endif
10240 : use pm_kind, only: SKC => SK2
10241 : character(*,SKC) , intent(in) :: lb, ub
10242 : integer(IK) , intent(in) :: s1, s2
10243 : character(len(lb,IK),SKC) :: rand(s1, s2)
10244 : type(xoshiro256ssg_type) , intent(inout) :: rng
10245 : end function
10246 : #endif
10247 :
10248 : #if SK1_ENABLED
10249 : impure module function getUnifRandRNGGLU_D2_SK1(rng, lb, ub, s1, s2) result(rand)
10250 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10251 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_SK1
10252 : #endif
10253 : use pm_kind, only: SKC => SK1
10254 : character(*,SKC) , intent(in) :: lb, ub
10255 : integer(IK) , intent(in) :: s1, s2
10256 : character(len(lb,IK),SKC) :: rand(s1, s2)
10257 : type(xoshiro256ssg_type) , intent(inout) :: rng
10258 : end function
10259 : #endif
10260 :
10261 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10262 :
10263 : #if IK5_ENABLED
10264 : impure module function getUnifRandRNGGLU_D2_IK5(rng, lb, ub, s1, s2) result(rand)
10265 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10266 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_IK5
10267 : #endif
10268 : use pm_kind, only: IKC => IK5
10269 : integer(IKC) , intent(in) :: lb, ub
10270 : integer(IK) , intent(in) :: s1, s2
10271 : integer(IKC) :: rand(s1, s2)
10272 : type(xoshiro256ssg_type) , intent(inout) :: rng
10273 : end function
10274 : #endif
10275 :
10276 : #if IK4_ENABLED
10277 : impure module function getUnifRandRNGGLU_D2_IK4(rng, lb, ub, s1, s2) result(rand)
10278 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10279 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_IK4
10280 : #endif
10281 : use pm_kind, only: IKC => IK4
10282 : integer(IKC) , intent(in) :: lb, ub
10283 : integer(IK) , intent(in) :: s1, s2
10284 : integer(IKC) :: rand(s1, s2)
10285 : type(xoshiro256ssg_type) , intent(inout) :: rng
10286 : end function
10287 : #endif
10288 :
10289 : #if IK3_ENABLED
10290 : impure module function getUnifRandRNGGLU_D2_IK3(rng, lb, ub, s1, s2) result(rand)
10291 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10292 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_IK3
10293 : #endif
10294 : use pm_kind, only: IKC => IK3
10295 : integer(IKC) , intent(in) :: lb, ub
10296 : integer(IK) , intent(in) :: s1, s2
10297 : integer(IKC) :: rand(s1, s2)
10298 : type(xoshiro256ssg_type) , intent(inout) :: rng
10299 : end function
10300 : #endif
10301 :
10302 : #if IK2_ENABLED
10303 : impure module function getUnifRandRNGGLU_D2_IK2(rng, lb, ub, s1, s2) result(rand)
10304 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10305 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_IK2
10306 : #endif
10307 : use pm_kind, only: IKC => IK2
10308 : integer(IKC) , intent(in) :: lb, ub
10309 : integer(IK) , intent(in) :: s1, s2
10310 : integer(IKC) :: rand(s1, s2)
10311 : type(xoshiro256ssg_type) , intent(inout) :: rng
10312 : end function
10313 : #endif
10314 :
10315 : #if IK1_ENABLED
10316 : impure module function getUnifRandRNGGLU_D2_IK1(rng, lb, ub, s1, s2) result(rand)
10317 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10318 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_IK1
10319 : #endif
10320 : use pm_kind, only: IKC => IK1
10321 : integer(IKC) , intent(in) :: lb, ub
10322 : integer(IK) , intent(in) :: s1, s2
10323 : integer(IKC) :: rand(s1, s2)
10324 : type(xoshiro256ssg_type) , intent(inout) :: rng
10325 : end function
10326 : #endif
10327 :
10328 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10329 :
10330 : #if LK5_ENABLED
10331 : impure module function getUnifRandRNGGLU_D2_LK5(rng, lb, ub, s1, s2) result(rand)
10332 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10333 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_LK5
10334 : #endif
10335 : use pm_kind, only: LKC => LK5
10336 : logical(LKC) , intent(in) :: lb, ub
10337 : integer(IK) , intent(in) :: s1, s2
10338 : logical(LKC) :: rand(s1, s2)
10339 : type(xoshiro256ssg_type) , intent(inout) :: rng
10340 : end function
10341 : #endif
10342 :
10343 : #if LK4_ENABLED
10344 : impure module function getUnifRandRNGGLU_D2_LK4(rng, lb, ub, s1, s2) result(rand)
10345 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10346 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_LK4
10347 : #endif
10348 : use pm_kind, only: LKC => LK4
10349 : logical(LKC) , intent(in) :: lb, ub
10350 : integer(IK) , intent(in) :: s1, s2
10351 : logical(LKC) :: rand(s1, s2)
10352 : type(xoshiro256ssg_type) , intent(inout) :: rng
10353 : end function
10354 : #endif
10355 :
10356 : #if LK3_ENABLED
10357 : impure module function getUnifRandRNGGLU_D2_LK3(rng, lb, ub, s1, s2) result(rand)
10358 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10359 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_LK3
10360 : #endif
10361 : use pm_kind, only: LKC => LK3
10362 : logical(LKC) , intent(in) :: lb, ub
10363 : integer(IK) , intent(in) :: s1, s2
10364 : logical(LKC) :: rand(s1, s2)
10365 : type(xoshiro256ssg_type) , intent(inout) :: rng
10366 : end function
10367 : #endif
10368 :
10369 : #if LK2_ENABLED
10370 : impure module function getUnifRandRNGGLU_D2_LK2(rng, lb, ub, s1, s2) result(rand)
10371 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10372 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_LK2
10373 : #endif
10374 : use pm_kind, only: LKC => LK2
10375 : logical(LKC) , intent(in) :: lb, ub
10376 : integer(IK) , intent(in) :: s1, s2
10377 : logical(LKC) :: rand(s1, s2)
10378 : type(xoshiro256ssg_type) , intent(inout) :: rng
10379 : end function
10380 : #endif
10381 :
10382 : #if LK1_ENABLED
10383 : impure module function getUnifRandRNGGLU_D2_LK1(rng, lb, ub, s1, s2) result(rand)
10384 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10385 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_LK1
10386 : #endif
10387 : use pm_kind, only: LKC => LK1
10388 : logical(LKC) , intent(in) :: lb, ub
10389 : integer(IK) , intent(in) :: s1, s2
10390 : logical(LKC) :: rand(s1, s2)
10391 : type(xoshiro256ssg_type) , intent(inout) :: rng
10392 : end function
10393 : #endif
10394 :
10395 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10396 :
10397 : #if CK5_ENABLED
10398 : impure module function getUnifRandRNGGLU_D2_CK5(rng, lb, ub, s1, s2) result(rand)
10399 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10400 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_CK5
10401 : #endif
10402 : use pm_kind, only: CKC => CK5
10403 : complex(CKC) , intent(in) :: lb, ub
10404 : integer(IK) , intent(in) :: s1, s2
10405 : complex(CKC) :: rand(s1, s2)
10406 : type(xoshiro256ssg_type) , intent(inout) :: rng
10407 : end function
10408 : #endif
10409 :
10410 : #if CK4_ENABLED
10411 : impure module function getUnifRandRNGGLU_D2_CK4(rng, lb, ub, s1, s2) result(rand)
10412 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10413 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_CK4
10414 : #endif
10415 : use pm_kind, only: CKC => CK4
10416 : complex(CKC) , intent(in) :: lb, ub
10417 : integer(IK) , intent(in) :: s1, s2
10418 : complex(CKC) :: rand(s1, s2)
10419 : type(xoshiro256ssg_type) , intent(inout) :: rng
10420 : end function
10421 : #endif
10422 :
10423 : #if CK3_ENABLED
10424 : impure module function getUnifRandRNGGLU_D2_CK3(rng, lb, ub, s1, s2) result(rand)
10425 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10426 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_CK3
10427 : #endif
10428 : use pm_kind, only: CKC => CK3
10429 : complex(CKC) , intent(in) :: lb, ub
10430 : integer(IK) , intent(in) :: s1, s2
10431 : complex(CKC) :: rand(s1, s2)
10432 : type(xoshiro256ssg_type) , intent(inout) :: rng
10433 : end function
10434 : #endif
10435 :
10436 : #if CK2_ENABLED
10437 : impure module function getUnifRandRNGGLU_D2_CK2(rng, lb, ub, s1, s2) result(rand)
10438 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10439 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_CK2
10440 : #endif
10441 : use pm_kind, only: CKC => CK2
10442 : complex(CKC) , intent(in) :: lb, ub
10443 : integer(IK) , intent(in) :: s1, s2
10444 : complex(CKC) :: rand(s1, s2)
10445 : type(xoshiro256ssg_type) , intent(inout) :: rng
10446 : end function
10447 : #endif
10448 :
10449 : #if CK1_ENABLED
10450 : impure module function getUnifRandRNGGLU_D2_CK1(rng, lb, ub, s1, s2) result(rand)
10451 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10452 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_CK1
10453 : #endif
10454 : use pm_kind, only: CKC => CK1
10455 : complex(CKC) , intent(in) :: lb, ub
10456 : integer(IK) , intent(in) :: s1, s2
10457 : complex(CKC) :: rand(s1, s2)
10458 : type(xoshiro256ssg_type) , intent(inout) :: rng
10459 : end function
10460 : #endif
10461 :
10462 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10463 :
10464 : #if RK5_ENABLED
10465 : impure module function getUnifRandRNGGLU_D2_RK5(rng, lb, ub, s1, s2) result(rand)
10466 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10467 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_RK5
10468 : #endif
10469 : use pm_kind, only: RKC => RK5
10470 : real(RKC) , intent(in) :: lb, ub
10471 : integer(IK) , intent(in) :: s1, s2
10472 : real(RKC) :: rand(s1, s2)
10473 : type(xoshiro256ssg_type) , intent(inout) :: rng
10474 : end function
10475 :
10476 : #endif
10477 :
10478 : #if RK4_ENABLED
10479 : impure module function getUnifRandRNGGLU_D2_RK4(rng, lb, ub, s1, s2) result(rand)
10480 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10481 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_RK4
10482 : #endif
10483 : use pm_kind, only: RKC => RK4
10484 : real(RKC) , intent(in) :: lb, ub
10485 : integer(IK) , intent(in) :: s1, s2
10486 : real(RKC) :: rand(s1, s2)
10487 : type(xoshiro256ssg_type) , intent(inout) :: rng
10488 : end function
10489 :
10490 : #endif
10491 :
10492 : #if RK3_ENABLED
10493 : impure module function getUnifRandRNGGLU_D2_RK3(rng, lb, ub, s1, s2) result(rand)
10494 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10495 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_RK3
10496 : #endif
10497 : use pm_kind, only: RKC => RK3
10498 : real(RKC) , intent(in) :: lb, ub
10499 : integer(IK) , intent(in) :: s1, s2
10500 : real(RKC) :: rand(s1, s2)
10501 : type(xoshiro256ssg_type) , intent(inout) :: rng
10502 : end function
10503 :
10504 : #endif
10505 :
10506 : #if RK2_ENABLED
10507 : impure module function getUnifRandRNGGLU_D2_RK2(rng, lb, ub, s1, s2) result(rand)
10508 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10509 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_RK2
10510 : #endif
10511 : use pm_kind, only: RKC => RK2
10512 : real(RKC) , intent(in) :: lb, ub
10513 : integer(IK) , intent(in) :: s1, s2
10514 : real(RKC) :: rand(s1, s2)
10515 : type(xoshiro256ssg_type) , intent(inout) :: rng
10516 : end function
10517 : #endif
10518 :
10519 : #if RK1_ENABLED
10520 : impure module function getUnifRandRNGGLU_D2_RK1(rng, lb, ub, s1, s2) result(rand)
10521 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10522 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D2_RK1
10523 : #endif
10524 : use pm_kind, only: RKC => RK1
10525 : real(RKC) , intent(in) :: lb, ub
10526 : integer(IK) , intent(in) :: s1, s2
10527 : real(RKC) :: rand(s1, s2)
10528 : type(xoshiro256ssg_type) , intent(inout) :: rng
10529 : end function
10530 : #endif
10531 :
10532 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10533 :
10534 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10535 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10536 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10537 :
10538 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10539 :
10540 : #if SK5_ENABLED
10541 : impure module function getUnifRandRNGGLU_D3_SK5(rng, lb, ub, s1, s2, s3) result(rand)
10542 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10543 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_SK5
10544 : #endif
10545 : use pm_kind, only: SKC => SK5
10546 : character(*,SKC) , intent(in) :: lb, ub
10547 : integer(IK) , intent(in) :: s1, s2, s3
10548 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
10549 : type(xoshiro256ssg_type) , intent(inout) :: rng
10550 : end function
10551 : #endif
10552 :
10553 : #if SK4_ENABLED
10554 : impure module function getUnifRandRNGGLU_D3_SK4(rng, lb, ub, s1, s2, s3) result(rand)
10555 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10556 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_SK4
10557 : #endif
10558 : use pm_kind, only: SKC => SK4
10559 : character(*,SKC) , intent(in) :: lb, ub
10560 : integer(IK) , intent(in) :: s1, s2, s3
10561 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
10562 : type(xoshiro256ssg_type) , intent(inout) :: rng
10563 : end function
10564 : #endif
10565 :
10566 : #if SK3_ENABLED
10567 : impure module function getUnifRandRNGGLU_D3_SK3(rng, lb, ub, s1, s2, s3) result(rand)
10568 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10569 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_SK3
10570 : #endif
10571 : use pm_kind, only: SKC => SK3
10572 : character(*,SKC) , intent(in) :: lb, ub
10573 : integer(IK) , intent(in) :: s1, s2, s3
10574 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
10575 : type(xoshiro256ssg_type) , intent(inout) :: rng
10576 : end function
10577 : #endif
10578 :
10579 : #if SK2_ENABLED
10580 : impure module function getUnifRandRNGGLU_D3_SK2(rng, lb, ub, s1, s2, s3) result(rand)
10581 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10582 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_SK2
10583 : #endif
10584 : use pm_kind, only: SKC => SK2
10585 : character(*,SKC) , intent(in) :: lb, ub
10586 : integer(IK) , intent(in) :: s1, s2, s3
10587 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
10588 : type(xoshiro256ssg_type) , intent(inout) :: rng
10589 : end function
10590 : #endif
10591 :
10592 : #if SK1_ENABLED
10593 : impure module function getUnifRandRNGGLU_D3_SK1(rng, lb, ub, s1, s2, s3) result(rand)
10594 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10595 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_SK1
10596 : #endif
10597 : use pm_kind, only: SKC => SK1
10598 : character(*,SKC) , intent(in) :: lb, ub
10599 : integer(IK) , intent(in) :: s1, s2, s3
10600 : character(len(lb,IK),SKC) :: rand(s1, s2, s3)
10601 : type(xoshiro256ssg_type) , intent(inout) :: rng
10602 : end function
10603 : #endif
10604 :
10605 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10606 :
10607 : #if IK5_ENABLED
10608 : impure module function getUnifRandRNGGLU_D3_IK5(rng, lb, ub, s1, s2, s3) result(rand)
10609 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10610 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_IK5
10611 : #endif
10612 : use pm_kind, only: IKC => IK5
10613 : integer(IKC) , intent(in) :: lb, ub
10614 : integer(IK) , intent(in) :: s1, s2, s3
10615 : integer(IKC) :: rand(s1, s2, s3)
10616 : type(xoshiro256ssg_type) , intent(inout) :: rng
10617 : end function
10618 : #endif
10619 :
10620 : #if IK4_ENABLED
10621 : impure module function getUnifRandRNGGLU_D3_IK4(rng, lb, ub, s1, s2, s3) result(rand)
10622 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10623 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_IK4
10624 : #endif
10625 : use pm_kind, only: IKC => IK4
10626 : integer(IKC) , intent(in) :: lb, ub
10627 : integer(IK) , intent(in) :: s1, s2, s3
10628 : integer(IKC) :: rand(s1, s2, s3)
10629 : type(xoshiro256ssg_type) , intent(inout) :: rng
10630 : end function
10631 : #endif
10632 :
10633 : #if IK3_ENABLED
10634 : impure module function getUnifRandRNGGLU_D3_IK3(rng, lb, ub, s1, s2, s3) result(rand)
10635 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10636 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_IK3
10637 : #endif
10638 : use pm_kind, only: IKC => IK3
10639 : integer(IKC) , intent(in) :: lb, ub
10640 : integer(IK) , intent(in) :: s1, s2, s3
10641 : integer(IKC) :: rand(s1, s2, s3)
10642 : type(xoshiro256ssg_type) , intent(inout) :: rng
10643 : end function
10644 : #endif
10645 :
10646 : #if IK2_ENABLED
10647 : impure module function getUnifRandRNGGLU_D3_IK2(rng, lb, ub, s1, s2, s3) result(rand)
10648 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10649 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_IK2
10650 : #endif
10651 : use pm_kind, only: IKC => IK2
10652 : integer(IKC) , intent(in) :: lb, ub
10653 : integer(IK) , intent(in) :: s1, s2, s3
10654 : integer(IKC) :: rand(s1, s2, s3)
10655 : type(xoshiro256ssg_type) , intent(inout) :: rng
10656 : end function
10657 : #endif
10658 :
10659 : #if IK1_ENABLED
10660 : impure module function getUnifRandRNGGLU_D3_IK1(rng, lb, ub, s1, s2, s3) result(rand)
10661 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10662 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_IK1
10663 : #endif
10664 : use pm_kind, only: IKC => IK1
10665 : integer(IKC) , intent(in) :: lb, ub
10666 : integer(IK) , intent(in) :: s1, s2, s3
10667 : integer(IKC) :: rand(s1, s2, s3)
10668 : type(xoshiro256ssg_type) , intent(inout) :: rng
10669 : end function
10670 : #endif
10671 :
10672 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10673 :
10674 : #if LK5_ENABLED
10675 : impure module function getUnifRandRNGGLU_D3_LK5(rng, lb, ub, s1, s2, s3) result(rand)
10676 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10677 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_LK5
10678 : #endif
10679 : use pm_kind, only: LKC => LK5
10680 : logical(LKC) , intent(in) :: lb, ub
10681 : integer(IK) , intent(in) :: s1, s2, s3
10682 : logical(LKC) :: rand(s1, s2, s3)
10683 : type(xoshiro256ssg_type) , intent(inout) :: rng
10684 : end function
10685 : #endif
10686 :
10687 : #if LK4_ENABLED
10688 : impure module function getUnifRandRNGGLU_D3_LK4(rng, lb, ub, s1, s2, s3) result(rand)
10689 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10690 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_LK4
10691 : #endif
10692 : use pm_kind, only: LKC => LK4
10693 : logical(LKC) , intent(in) :: lb, ub
10694 : integer(IK) , intent(in) :: s1, s2, s3
10695 : logical(LKC) :: rand(s1, s2, s3)
10696 : type(xoshiro256ssg_type) , intent(inout) :: rng
10697 : end function
10698 : #endif
10699 :
10700 : #if LK3_ENABLED
10701 : impure module function getUnifRandRNGGLU_D3_LK3(rng, lb, ub, s1, s2, s3) result(rand)
10702 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10703 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_LK3
10704 : #endif
10705 : use pm_kind, only: LKC => LK3
10706 : logical(LKC) , intent(in) :: lb, ub
10707 : integer(IK) , intent(in) :: s1, s2, s3
10708 : logical(LKC) :: rand(s1, s2, s3)
10709 : type(xoshiro256ssg_type) , intent(inout) :: rng
10710 : end function
10711 : #endif
10712 :
10713 : #if LK2_ENABLED
10714 : impure module function getUnifRandRNGGLU_D3_LK2(rng, lb, ub, s1, s2, s3) result(rand)
10715 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10716 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_LK2
10717 : #endif
10718 : use pm_kind, only: LKC => LK2
10719 : logical(LKC) , intent(in) :: lb, ub
10720 : integer(IK) , intent(in) :: s1, s2, s3
10721 : logical(LKC) :: rand(s1, s2, s3)
10722 : type(xoshiro256ssg_type) , intent(inout) :: rng
10723 : end function
10724 : #endif
10725 :
10726 : #if LK1_ENABLED
10727 : impure module function getUnifRandRNGGLU_D3_LK1(rng, lb, ub, s1, s2, s3) result(rand)
10728 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10729 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_LK1
10730 : #endif
10731 : use pm_kind, only: LKC => LK1
10732 : logical(LKC) , intent(in) :: lb, ub
10733 : integer(IK) , intent(in) :: s1, s2, s3
10734 : logical(LKC) :: rand(s1, s2, s3)
10735 : type(xoshiro256ssg_type) , intent(inout) :: rng
10736 : end function
10737 : #endif
10738 :
10739 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10740 :
10741 : #if CK5_ENABLED
10742 : impure module function getUnifRandRNGGLU_D3_CK5(rng, lb, ub, s1, s2, s3) result(rand)
10743 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10744 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_CK5
10745 : #endif
10746 : use pm_kind, only: CKC => CK5
10747 : complex(CKC) , intent(in) :: lb, ub
10748 : integer(IK) , intent(in) :: s1, s2, s3
10749 : complex(CKC) :: rand(s1, s2, s3)
10750 : type(xoshiro256ssg_type) , intent(inout) :: rng
10751 : end function
10752 : #endif
10753 :
10754 : #if CK4_ENABLED
10755 : impure module function getUnifRandRNGGLU_D3_CK4(rng, lb, ub, s1, s2, s3) result(rand)
10756 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10757 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_CK4
10758 : #endif
10759 : use pm_kind, only: CKC => CK4
10760 : complex(CKC) , intent(in) :: lb, ub
10761 : integer(IK) , intent(in) :: s1, s2, s3
10762 : complex(CKC) :: rand(s1, s2, s3)
10763 : type(xoshiro256ssg_type) , intent(inout) :: rng
10764 : end function
10765 : #endif
10766 :
10767 : #if CK3_ENABLED
10768 : impure module function getUnifRandRNGGLU_D3_CK3(rng, lb, ub, s1, s2, s3) result(rand)
10769 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10770 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_CK3
10771 : #endif
10772 : use pm_kind, only: CKC => CK3
10773 : complex(CKC) , intent(in) :: lb, ub
10774 : integer(IK) , intent(in) :: s1, s2, s3
10775 : complex(CKC) :: rand(s1, s2, s3)
10776 : type(xoshiro256ssg_type) , intent(inout) :: rng
10777 : end function
10778 : #endif
10779 :
10780 : #if CK2_ENABLED
10781 : impure module function getUnifRandRNGGLU_D3_CK2(rng, lb, ub, s1, s2, s3) result(rand)
10782 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10783 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_CK2
10784 : #endif
10785 : use pm_kind, only: CKC => CK2
10786 : complex(CKC) , intent(in) :: lb, ub
10787 : integer(IK) , intent(in) :: s1, s2, s3
10788 : complex(CKC) :: rand(s1, s2, s3)
10789 : type(xoshiro256ssg_type) , intent(inout) :: rng
10790 : end function
10791 : #endif
10792 :
10793 : #if CK1_ENABLED
10794 : impure module function getUnifRandRNGGLU_D3_CK1(rng, lb, ub, s1, s2, s3) result(rand)
10795 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10796 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_CK1
10797 : #endif
10798 : use pm_kind, only: CKC => CK1
10799 : complex(CKC) , intent(in) :: lb, ub
10800 : integer(IK) , intent(in) :: s1, s2, s3
10801 : complex(CKC) :: rand(s1, s2, s3)
10802 : type(xoshiro256ssg_type) , intent(inout) :: rng
10803 : end function
10804 : #endif
10805 :
10806 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10807 :
10808 : #if RK5_ENABLED
10809 : impure module function getUnifRandRNGGLU_D3_RK5(rng, lb, ub, s1, s2, s3) result(rand)
10810 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10811 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_RK5
10812 : #endif
10813 : use pm_kind, only: RKC => RK5
10814 : real(RKC) , intent(in) :: lb, ub
10815 : integer(IK) , intent(in) :: s1, s2, s3
10816 : real(RKC) :: rand(s1, s2, s3)
10817 : type(xoshiro256ssg_type) , intent(inout) :: rng
10818 : end function
10819 :
10820 : #endif
10821 :
10822 : #if RK4_ENABLED
10823 : impure module function getUnifRandRNGGLU_D3_RK4(rng, lb, ub, s1, s2, s3) result(rand)
10824 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10825 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_RK4
10826 : #endif
10827 : use pm_kind, only: RKC => RK4
10828 : real(RKC) , intent(in) :: lb, ub
10829 : integer(IK) , intent(in) :: s1, s2, s3
10830 : real(RKC) :: rand(s1, s2, s3)
10831 : type(xoshiro256ssg_type) , intent(inout) :: rng
10832 : end function
10833 :
10834 : #endif
10835 :
10836 : #if RK3_ENABLED
10837 : impure module function getUnifRandRNGGLU_D3_RK3(rng, lb, ub, s1, s2, s3) result(rand)
10838 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10839 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_RK3
10840 : #endif
10841 : use pm_kind, only: RKC => RK3
10842 : real(RKC) , intent(in) :: lb, ub
10843 : integer(IK) , intent(in) :: s1, s2, s3
10844 : real(RKC) :: rand(s1, s2, s3)
10845 : type(xoshiro256ssg_type) , intent(inout) :: rng
10846 : end function
10847 :
10848 : #endif
10849 :
10850 : #if RK2_ENABLED
10851 : impure module function getUnifRandRNGGLU_D3_RK2(rng, lb, ub, s1, s2, s3) result(rand)
10852 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10853 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_RK2
10854 : #endif
10855 : use pm_kind, only: RKC => RK2
10856 : real(RKC) , intent(in) :: lb, ub
10857 : integer(IK) , intent(in) :: s1, s2, s3
10858 : real(RKC) :: rand(s1, s2, s3)
10859 : type(xoshiro256ssg_type) , intent(inout) :: rng
10860 : end function
10861 : #endif
10862 :
10863 : #if RK1_ENABLED
10864 : impure module function getUnifRandRNGGLU_D3_RK1(rng, lb, ub, s1, s2, s3) result(rand)
10865 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10866 : !DEC$ ATTRIBUTES DLLEXPORT :: getUnifRandRNGGLU_D3_RK1
10867 : #endif
10868 : use pm_kind, only: RKC => RK1
10869 : real(RKC) , intent(in) :: lb, ub
10870 : integer(IK) , intent(in) :: s1, s2, s3
10871 : real(RKC) :: rand(s1, s2, s3)
10872 : type(xoshiro256ssg_type) , intent(inout) :: rng
10873 : end function
10874 : #endif
10875 :
10876 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10877 :
10878 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10879 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10880 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10881 :
10882 : end interface
10883 :
10884 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10885 :
10886 : !> \brief
10887 : !> Return a uniform random scalar or `contiguous` array of arbitrary rank of randomly uniformly distributed discrete
10888 : !> `logical`, `integer`, `character` value(s), or continuous `real` or `complex value(s) within the specified input range.
10889 : !>
10890 : !> \param[inout] rng : The input/output scalar of type,
10891 : !> <ol>
10892 : !> <li> [rngf_type](@ref pm_distUnif::rngf_type), or
10893 : !> <li> [splitmix64_type](@ref pm_distUnif::splitmix64_type), or
10894 : !> <li> [xoshiro256ssg_type](@ref pm_distUnif::xoshiro256ssg_type),
10895 : !> <li> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type),
10896 : !> </ol>
10897 : !> containing the user-specified random number generator algorithm to be used.<br>
10898 : !> The user must initialize the object with the corresponding type constructors if non-deterministic RNG are desired.
10899 : !> (**optional**, default = [rngf_type](@ref pm_distUnif::rngf_type))
10900 : !> \param[out] rand : The output object of either<br>
10901 : !> <ol>
10902 : !> <li> scalar of type `character` of kind \SKALL of arbitrary `len` type parameter or, <br>
10903 : !> </ol>
10904 : !> or `contiguous` array of the rank, shape, and size as other array-like arguments, of either <br>
10905 : !> <ol>
10906 : !> <li> type `character` of kind \SKALL of arbitrary `len` type parameter or, <br>
10907 : !> <li> type `integer` of kind \IKALL or, <br>
10908 : !> <li> type `complex` of kind \CKALL or, <br>
10909 : !> <li> type `real` of kind \RKALL or, <br>
10910 : !> <li> type `logical` of kind \LKALL, <br>
10911 : !> </ol>
10912 : !> containing the uniformly-distributed random output value.<br>
10913 : !> <ol>
10914 : !> <li> If `rand` is of type `logical`, its value is either `.false.` or `.true.`.<br>
10915 : !> <li> If `rand` is of type `integer`, its value is in the interval `[lb, ub]`.<br>
10916 : !> <li> If `rand` is of type `complex` or `real`, its value is in the interval `[lb, ub)`.<br>
10917 : !> <li> If `rand` is of type `character`, its value is by default in the interval `[char(1), char(127)]`.<br>
10918 : !> </ol>
10919 : !> \param[in] lb : The input scalar (or array of the same rank, shape, and size as other array-like arguments),
10920 : !> of the same type and kind as `rand`, representing the lower bound of the Uniform distribution.<br>
10921 : !> <ol>
10922 : !> <li> If `rand` is of type `character`, then `len(rand) == len(lb)` must hold.<br>
10923 : !> <li> If `rand` is of type `logical`, then `lb` must be `.false.` (there is no other possibility).<br>
10924 : !> </ol>
10925 : !> (**optional**, default = `char(1)`, `repeat(char(1), len(rand))`, `-huge(rand)`, `.false.`, `(0.,0.)`, or `0.`,
10926 : !> for a scalar `character`, vector `character`, `integer`, `complex`, or `real` output `rand`, respectively.<br>
10927 : !> It must be present <b>if and only if</b> `ub` is also present.)
10928 : !> \param[in] ub : The input scalar (or array of the same shape as `rand`) of the same type and kind as `rand`,
10929 : !> representing the upper bound of the Uniform distribution.<br>
10930 : !> If `rand` is of type `character`, then `len(rand) == len(ub)` must hold.<br>
10931 : !> If `rand` is of type `logical`, then `ub` does not exist as an input argument (it must not be present).<br>
10932 : !> (**optional**, default = `char(127)`, `repeat(char(127), len(rand))`, `+huge(rand)`, `.true.`, `(1.,1.)`, or `1.`,
10933 : !> for a scalar `character`, vector `character`, `integer`, `complex`, or `real` output `rand`, respectively.<br>
10934 : !> It must be present <b>if and only if</b> `ub` is also present.)
10935 : !>
10936 : !> \interface{setUnifRand}
10937 : !> \code{.F90}
10938 : !>
10939 : !> use pm_distUnif, only: setUnifRand
10940 : !>
10941 : !> call setUnifRand(rand) ! `rand` can be any intrinsic type: character, complex, logical, integer, real.
10942 : !> call setUnifRand(rand, lb, ub) ! `rand` can be any intrinsic type: character, complex, logical, integer, real.
10943 : !>
10944 : !> call setUnifRand(rng, rand) ! `rand` can be any intrinsic type: character, complex, logical, integer, real.
10945 : !> call setUnifRand(rng, rand, lb, ub) ! `rand` can be any intrinsic type: character, complex, logical, integer, real.
10946 : !> !
10947 : !> \endcode
10948 : !>
10949 : !> \warning
10950 : !> The condition `len(lb) == len(ub) .or. len(lb) == 1 .or. len(ub) == 1` for the corresponding input arguments of type `character`.<br>
10951 : !> The condition `lb <= ub` must hold for the corresponding input arguments where
10952 : !> logical values are compared by the procedures of module [pm_logicalCompare](@ref pm_logicalCompare) and
10953 : !> complex values are compared by the procedures of module [pm_complexCompareAll](@ref pm_complexCompareAll).<br>
10954 : !> \vericons
10955 : !>
10956 : !> \impure
10957 : !> The procedures of this generic interface are `pure` when the argument `rng` is present.<br>
10958 : !>
10959 : !> \elemental
10960 : !> The procedures of this generic interface are non-`elemental` when the argument `rng` is present.<br>
10961 : !>
10962 : !> \remark
10963 : !> The procedures under this generic interface are carefully designed to avoid possible overflow due to
10964 : !> specifying huge negative and positive `lb` and `ub` limits of type `integer`, `complex`, `real`.<br>
10965 : !> This is possible at the cost of making the random number generation slightly more expensive
10966 : !> (by a few CPU cycles, equivalent to and extra multiplication).<br>
10967 : !>
10968 : !> \remark
10969 : !> It is expected that the condition `lb <= ub` if the two input arguments are specified by the user.<br>
10970 : !> However, this condition is neither enforced nor checked at runtime within the procedures.<br>
10971 : !>
10972 : !> \note
10973 : !> By default random characters are generated from the ASCII collating sequence to ensure portability across compilers and platforms.<br>
10974 : !> If random uniform characters from the processor's collating sequence are desired, specify the `lb`
10975 : !> and `ub` inputs argument as `integer`s of default kind \IK, such that the random numbers are generated from the
10976 : !> processor-dependent character interval `[char(lb), char(ub)]`.<br>
10977 : !>
10978 : !> \see
10979 : !> [rngf](@ref pm_distUnif::rngf)<br>
10980 : !> [isHead](@ref pm_distBern::isHead)<br>
10981 : !> [getUnifCDF](@ref pm_distUnif::getUnifCDF)<br>
10982 : !> [getUnifRand](@ref pm_distUnif::getUnifRand)<br>
10983 : !> [setUnifRand](@ref pm_distUnif::setUnifRand)<br>
10984 : !> [getUnifRandState](@ref pm_distUnif::getUnifRandState)<br>
10985 : !> [setUnifRandState](@ref pm_distUnif::setUnifRandState)<br>
10986 : !> [rngu_type](@ref pm_distUnif::rngu_type)<br>
10987 : !> [rngf_type](@ref pm_distUnif::rngf_type)<br>
10988 : !> [splitmix64_type](@ref pm_distUnif::splitmix64_type)<br>
10989 : !> [xoshiro256ssw_type](@ref pm_distUnif::xoshiro256ssw_type)<br>
10990 : !> [getUnifRandStateSize](@ref pm_distUnif::getUnifRandStateSize)<br>
10991 : !>
10992 : !> \example{setUnifRand}
10993 : !> \include{lineno} example/pm_distUnif/setUnifRand/main.F90
10994 : !> \compilef{setUnifRand}
10995 : !> \output{setUnifRand}
10996 : !> \include{lineno} example/pm_distUnif/setUnifRand/main.out.F90
10997 : !> \postproc{setUnifRand}
10998 : !> \include{lineno} example/pm_distUnif/setUnifRand/main.py
10999 : !> \vis{setUnifRand}
11000 : !> \image html pm_distUnif/setUnifRand/setUnifRand.IK.png width=700
11001 : !> \image html pm_distUnif/setUnifRand/setUnifRand.CK.png width=700
11002 : !> \image html pm_distUnif/setUnifRand/setUnifRand.RK.png width=700
11003 : !>
11004 : !> \test
11005 : !> [test_pm_distUnif](@ref test_pm_distUnif)
11006 : !>
11007 : !> \bug
11008 : !> \status \unresolved
11009 : !> \source \gfortran{10.3}
11010 : !> \desc
11011 : !> \gfortran yields an internal compiler error with the expression `rand = nint(temp, kind = IKC)`
11012 : !> in `pm_distUnif@routines@IK.inc.F90` file when `IKC => integer_kinds(5)` on WSL OS.<br>
11013 : !> \remedy
11014 : !> For now, the expression is replaced with `rand = int(0.5d0 + temp, kind = IKC)`.<br>
11015 : !>
11016 : !> \finmain{setUnifRand}
11017 : !>
11018 : !> \author
11019 : !> \AmirShahmoradi, Oct 16, 2009, 11:14 AM, Michigan
11020 :
11021 : ! RNGD
11022 :
11023 : interface setUnifRand
11024 :
11025 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11026 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11027 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11028 :
11029 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11030 :
11031 : #if SK5_ENABLED
11032 : impure elemental module subroutine setUnifRandRNGDDD_D0_SK5(rand)
11033 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11034 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_SK5
11035 : #endif
11036 : use pm_kind, only: SKC => SK5
11037 : character(*,SKC) , intent(out) :: rand
11038 : end subroutine
11039 : #endif
11040 :
11041 : #if SK4_ENABLED
11042 : impure elemental module subroutine setUnifRandRNGDDD_D0_SK4(rand)
11043 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11044 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_SK4
11045 : #endif
11046 : use pm_kind, only: SKC => SK4
11047 : character(*,SKC) , intent(out) :: rand
11048 : end subroutine
11049 : #endif
11050 :
11051 : #if SK3_ENABLED
11052 : impure elemental module subroutine setUnifRandRNGDDD_D0_SK3(rand)
11053 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11054 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_SK3
11055 : #endif
11056 : use pm_kind, only: SKC => SK3
11057 : character(*,SKC) , intent(out) :: rand
11058 : end subroutine
11059 : #endif
11060 :
11061 : #if SK2_ENABLED
11062 : impure elemental module subroutine setUnifRandRNGDDD_D0_SK2(rand)
11063 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11064 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_SK2
11065 : #endif
11066 : use pm_kind, only: SKC => SK2
11067 : character(*,SKC) , intent(out) :: rand
11068 : end subroutine
11069 : #endif
11070 :
11071 : #if SK1_ENABLED
11072 : impure elemental module subroutine setUnifRandRNGDDD_D0_SK1(rand)
11073 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11074 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_SK1
11075 : #endif
11076 : use pm_kind, only: SKC => SK1
11077 : character(*,SKC) , intent(out) :: rand
11078 : end subroutine
11079 : #endif
11080 :
11081 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11082 :
11083 : #if IK5_ENABLED
11084 : impure elemental module subroutine setUnifRandRNGDDD_D0_IK5(rand)
11085 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11086 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_IK5
11087 : #endif
11088 : use pm_kind, only: IKC => IK5
11089 : integer(IKC) , intent(out) :: rand
11090 : end subroutine
11091 : #endif
11092 :
11093 : #if IK4_ENABLED
11094 : impure elemental module subroutine setUnifRandRNGDDD_D0_IK4(rand)
11095 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11096 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_IK4
11097 : #endif
11098 : use pm_kind, only: IKC => IK4
11099 : integer(IKC) , intent(out) :: rand
11100 : end subroutine
11101 : #endif
11102 :
11103 : #if IK3_ENABLED
11104 : impure elemental module subroutine setUnifRandRNGDDD_D0_IK3(rand)
11105 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11106 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_IK3
11107 : #endif
11108 : use pm_kind, only: IKC => IK3
11109 : integer(IKC) , intent(out) :: rand
11110 : end subroutine
11111 : #endif
11112 :
11113 : #if IK2_ENABLED
11114 : impure elemental module subroutine setUnifRandRNGDDD_D0_IK2(rand)
11115 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11116 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_IK2
11117 : #endif
11118 : use pm_kind, only: IKC => IK2
11119 : integer(IKC) , intent(out) :: rand
11120 : end subroutine
11121 : #endif
11122 :
11123 : #if IK1_ENABLED
11124 : impure elemental module subroutine setUnifRandRNGDDD_D0_IK1(rand)
11125 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11126 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_IK1
11127 : #endif
11128 : use pm_kind, only: IKC => IK1
11129 : integer(IKC) , intent(out) :: rand
11130 : end subroutine
11131 : #endif
11132 :
11133 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11134 :
11135 : #if LK5_ENABLED
11136 : impure elemental module subroutine setUnifRandRNGDDD_D0_LK5(rand)
11137 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11138 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_LK5
11139 : #endif
11140 : use pm_kind, only: LKC => LK5
11141 : logical(LKC) , intent(out) :: rand
11142 : end subroutine
11143 : #endif
11144 :
11145 : #if LK4_ENABLED
11146 : impure elemental module subroutine setUnifRandRNGDDD_D0_LK4(rand)
11147 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11148 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_LK4
11149 : #endif
11150 : use pm_kind, only: LKC => LK4
11151 : logical(LKC) , intent(out) :: rand
11152 : end subroutine
11153 : #endif
11154 :
11155 : #if LK3_ENABLED
11156 : impure elemental module subroutine setUnifRandRNGDDD_D0_LK3(rand)
11157 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11158 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_LK3
11159 : #endif
11160 : use pm_kind, only: LKC => LK3
11161 : logical(LKC) , intent(out) :: rand
11162 : end subroutine
11163 : #endif
11164 :
11165 : #if LK2_ENABLED
11166 : impure elemental module subroutine setUnifRandRNGDDD_D0_LK2(rand)
11167 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11168 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_LK2
11169 : #endif
11170 : use pm_kind, only: LKC => LK2
11171 : logical(LKC) , intent(out) :: rand
11172 : end subroutine
11173 : #endif
11174 :
11175 : #if LK1_ENABLED
11176 : impure elemental module subroutine setUnifRandRNGDDD_D0_LK1(rand)
11177 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11178 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_LK1
11179 : #endif
11180 : use pm_kind, only: LKC => LK1
11181 : logical(LKC) , intent(out) :: rand
11182 : end subroutine
11183 : #endif
11184 :
11185 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11186 :
11187 : #if CK5_ENABLED
11188 : impure elemental module subroutine setUnifRandRNGDDD_D0_CK5(rand)
11189 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11190 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_CK5
11191 : #endif
11192 : use pm_kind, only: CKC => CK5
11193 : complex(CKC) , intent(out) :: rand
11194 : end subroutine
11195 : #endif
11196 :
11197 : #if CK4_ENABLED
11198 : impure elemental module subroutine setUnifRandRNGDDD_D0_CK4(rand)
11199 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11200 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_CK4
11201 : #endif
11202 : use pm_kind, only: CKC => CK4
11203 : complex(CKC) , intent(out) :: rand
11204 : end subroutine
11205 : #endif
11206 :
11207 : #if CK3_ENABLED
11208 : impure elemental module subroutine setUnifRandRNGDDD_D0_CK3(rand)
11209 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11210 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_CK3
11211 : #endif
11212 : use pm_kind, only: CKC => CK3
11213 : complex(CKC) , intent(out) :: rand
11214 : end subroutine
11215 : #endif
11216 :
11217 : #if CK2_ENABLED
11218 : impure elemental module subroutine setUnifRandRNGDDD_D0_CK2(rand)
11219 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11220 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_CK2
11221 : #endif
11222 : use pm_kind, only: CKC => CK2
11223 : complex(CKC) , intent(out) :: rand
11224 : end subroutine
11225 : #endif
11226 :
11227 : #if CK1_ENABLED
11228 : impure elemental module subroutine setUnifRandRNGDDD_D0_CK1(rand)
11229 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11230 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_CK1
11231 : #endif
11232 : use pm_kind, only: CKC => CK1
11233 : complex(CKC) , intent(out) :: rand
11234 : end subroutine
11235 : #endif
11236 :
11237 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11238 :
11239 : #if RK5_ENABLED
11240 : impure elemental module subroutine setUnifRandRNGDDD_D0_RK5(rand)
11241 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11242 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_RK5
11243 : #endif
11244 : use pm_kind, only: RKC => RK5
11245 : real(RKC) , intent(out) :: rand
11246 : end subroutine
11247 : #endif
11248 :
11249 : #if RK4_ENABLED
11250 : impure elemental module subroutine setUnifRandRNGDDD_D0_RK4(rand)
11251 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11252 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_RK4
11253 : #endif
11254 : use pm_kind, only: RKC => RK4
11255 : real(RKC) , intent(out) :: rand
11256 : end subroutine
11257 : #endif
11258 :
11259 : #if RK3_ENABLED
11260 : impure elemental module subroutine setUnifRandRNGDDD_D0_RK3(rand)
11261 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11262 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_RK3
11263 : #endif
11264 : use pm_kind, only: RKC => RK3
11265 : real(RKC) , intent(out) :: rand
11266 : end subroutine
11267 : #endif
11268 :
11269 : #if RK2_ENABLED
11270 : impure elemental module subroutine setUnifRandRNGDDD_D0_RK2(rand)
11271 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11272 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_RK2
11273 : #endif
11274 : use pm_kind, only: RKC => RK2
11275 : real(RKC) , intent(out) :: rand
11276 : end subroutine
11277 : #endif
11278 :
11279 : #if RK1_ENABLED
11280 : impure elemental module subroutine setUnifRandRNGDDD_D0_RK1(rand)
11281 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11282 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDDD_D0_RK1
11283 : #endif
11284 : use pm_kind, only: RKC => RK1
11285 : real(RKC) , intent(out) :: rand
11286 : end subroutine
11287 : #endif
11288 :
11289 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11290 :
11291 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11292 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11293 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11294 :
11295 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11296 :
11297 : #if SK5_ENABLED
11298 : impure elemental module subroutine setUnifRandRNGDLU_D0_SK5(rand, lb, ub)
11299 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11300 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_SK5
11301 : #endif
11302 : use pm_kind, only: SKC => SK5
11303 : character(*,SKC) , intent(out) :: rand
11304 : character(*,SKC) , intent(in) :: lb, ub
11305 : end subroutine
11306 : #endif
11307 :
11308 : #if SK4_ENABLED
11309 : impure elemental module subroutine setUnifRandRNGDLU_D0_SK4(rand, lb, ub)
11310 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11311 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_SK4
11312 : #endif
11313 : use pm_kind, only: SKC => SK4
11314 : character(*,SKC) , intent(out) :: rand
11315 : character(*,SKC) , intent(in) :: lb, ub
11316 : end subroutine
11317 : #endif
11318 :
11319 : #if SK3_ENABLED
11320 : impure elemental module subroutine setUnifRandRNGDLU_D0_SK3(rand, lb, ub)
11321 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11322 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_SK3
11323 : #endif
11324 : use pm_kind, only: SKC => SK3
11325 : character(*,SKC) , intent(out) :: rand
11326 : character(*,SKC) , intent(in) :: lb, ub
11327 : end subroutine
11328 : #endif
11329 :
11330 : #if SK2_ENABLED
11331 : impure elemental module subroutine setUnifRandRNGDLU_D0_SK2(rand, lb, ub)
11332 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11333 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_SK2
11334 : #endif
11335 : use pm_kind, only: SKC => SK2
11336 : character(*,SKC) , intent(out) :: rand
11337 : character(*,SKC) , intent(in) :: lb, ub
11338 : end subroutine
11339 : #endif
11340 :
11341 : #if SK1_ENABLED
11342 : impure elemental module subroutine setUnifRandRNGDLU_D0_SK1(rand, lb, ub)
11343 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11344 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_SK1
11345 : #endif
11346 : use pm_kind, only: SKC => SK1
11347 : character(*,SKC) , intent(out) :: rand
11348 : character(*,SKC) , intent(in) :: lb, ub
11349 : end subroutine
11350 : #endif
11351 :
11352 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11353 :
11354 : #if IK5_ENABLED
11355 : impure elemental module subroutine setUnifRandRNGDLU_D0_IK5(rand, lb, ub)
11356 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11357 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_IK5
11358 : #endif
11359 : use pm_kind, only: IKC => IK5
11360 : integer(IKC) , intent(out) :: rand
11361 : integer(IKC) , intent(in) :: lb, ub
11362 : end subroutine
11363 : #endif
11364 :
11365 : #if IK4_ENABLED
11366 : impure elemental module subroutine setUnifRandRNGDLU_D0_IK4(rand, lb, ub)
11367 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11368 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_IK4
11369 : #endif
11370 : use pm_kind, only: IKC => IK4
11371 : integer(IKC) , intent(out) :: rand
11372 : integer(IKC) , intent(in) :: lb, ub
11373 : end subroutine
11374 : #endif
11375 :
11376 : #if IK3_ENABLED
11377 : impure elemental module subroutine setUnifRandRNGDLU_D0_IK3(rand, lb, ub)
11378 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11379 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_IK3
11380 : #endif
11381 : use pm_kind, only: IKC => IK3
11382 : integer(IKC) , intent(out) :: rand
11383 : integer(IKC) , intent(in) :: lb, ub
11384 : end subroutine
11385 : #endif
11386 :
11387 : #if IK2_ENABLED
11388 : impure elemental module subroutine setUnifRandRNGDLU_D0_IK2(rand, lb, ub)
11389 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11390 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_IK2
11391 : #endif
11392 : use pm_kind, only: IKC => IK2
11393 : integer(IKC) , intent(out) :: rand
11394 : integer(IKC) , intent(in) :: lb, ub
11395 : end subroutine
11396 : #endif
11397 :
11398 : #if IK1_ENABLED
11399 : impure elemental module subroutine setUnifRandRNGDLU_D0_IK1(rand, lb, ub)
11400 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11401 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_IK1
11402 : #endif
11403 : use pm_kind, only: IKC => IK1
11404 : integer(IKC) , intent(out) :: rand
11405 : integer(IKC) , intent(in) :: lb, ub
11406 : end subroutine
11407 : #endif
11408 :
11409 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11410 :
11411 : #if LK5_ENABLED
11412 : impure elemental module subroutine setUnifRandRNGDLU_D0_LK5(rand, lb, ub)
11413 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11414 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_LK5
11415 : #endif
11416 : use pm_kind, only: LKC => LK5
11417 : logical(LKC) , intent(out) :: rand
11418 : logical(LKC) , intent(in) :: lb, ub
11419 : end subroutine
11420 : #endif
11421 :
11422 : #if LK4_ENABLED
11423 : impure elemental module subroutine setUnifRandRNGDLU_D0_LK4(rand, lb, ub)
11424 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11425 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_LK4
11426 : #endif
11427 : use pm_kind, only: LKC => LK4
11428 : logical(LKC) , intent(out) :: rand
11429 : logical(LKC) , intent(in) :: lb, ub
11430 : end subroutine
11431 : #endif
11432 :
11433 : #if LK3_ENABLED
11434 : impure elemental module subroutine setUnifRandRNGDLU_D0_LK3(rand, lb, ub)
11435 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11436 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_LK3
11437 : #endif
11438 : use pm_kind, only: LKC => LK3
11439 : logical(LKC) , intent(out) :: rand
11440 : logical(LKC) , intent(in) :: lb, ub
11441 : end subroutine
11442 : #endif
11443 :
11444 : #if LK2_ENABLED
11445 : impure elemental module subroutine setUnifRandRNGDLU_D0_LK2(rand, lb, ub)
11446 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11447 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_LK2
11448 : #endif
11449 : use pm_kind, only: LKC => LK2
11450 : logical(LKC) , intent(out) :: rand
11451 : logical(LKC) , intent(in) :: lb, ub
11452 : end subroutine
11453 : #endif
11454 :
11455 : #if LK1_ENABLED
11456 : impure elemental module subroutine setUnifRandRNGDLU_D0_LK1(rand, lb, ub)
11457 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11458 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_LK1
11459 : #endif
11460 : use pm_kind, only: LKC => LK1
11461 : logical(LKC) , intent(out) :: rand
11462 : logical(LKC) , intent(in) :: lb, ub
11463 : end subroutine
11464 : #endif
11465 :
11466 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11467 :
11468 : #if CK5_ENABLED
11469 : impure elemental module subroutine setUnifRandRNGDLU_D0_CK5(rand, lb, ub)
11470 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11471 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_CK5
11472 : #endif
11473 : use pm_kind, only: CKC => CK5
11474 : complex(CKC) , intent(out) :: rand
11475 : complex(CKC) , intent(in) :: lb, ub
11476 : end subroutine
11477 : #endif
11478 :
11479 : #if CK4_ENABLED
11480 : impure elemental module subroutine setUnifRandRNGDLU_D0_CK4(rand, lb, ub)
11481 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11482 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_CK4
11483 : #endif
11484 : use pm_kind, only: CKC => CK4
11485 : complex(CKC) , intent(out) :: rand
11486 : complex(CKC) , intent(in) :: lb, ub
11487 : end subroutine
11488 : #endif
11489 :
11490 : #if CK3_ENABLED
11491 : impure elemental module subroutine setUnifRandRNGDLU_D0_CK3(rand, lb, ub)
11492 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11493 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_CK3
11494 : #endif
11495 : use pm_kind, only: CKC => CK3
11496 : complex(CKC) , intent(out) :: rand
11497 : complex(CKC) , intent(in) :: lb, ub
11498 : end subroutine
11499 : #endif
11500 :
11501 : #if CK2_ENABLED
11502 : impure elemental module subroutine setUnifRandRNGDLU_D0_CK2(rand, lb, ub)
11503 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11504 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_CK2
11505 : #endif
11506 : use pm_kind, only: CKC => CK2
11507 : complex(CKC) , intent(out) :: rand
11508 : complex(CKC) , intent(in) :: lb, ub
11509 : end subroutine
11510 : #endif
11511 :
11512 : #if CK1_ENABLED
11513 : impure elemental module subroutine setUnifRandRNGDLU_D0_CK1(rand, lb, ub)
11514 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11515 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_CK1
11516 : #endif
11517 : use pm_kind, only: CKC => CK1
11518 : complex(CKC) , intent(out) :: rand
11519 : complex(CKC) , intent(in) :: lb, ub
11520 : end subroutine
11521 : #endif
11522 :
11523 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11524 :
11525 : #if RK5_ENABLED
11526 : impure elemental module subroutine setUnifRandRNGDLU_D0_RK5(rand, lb, ub)
11527 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11528 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_RK5
11529 : #endif
11530 : use pm_kind, only: RKC => RK5
11531 : real(RKC) , intent(out) :: rand
11532 : real(RKC) , intent(in) :: lb, ub
11533 : end subroutine
11534 : #endif
11535 :
11536 : #if RK4_ENABLED
11537 : impure elemental module subroutine setUnifRandRNGDLU_D0_RK4(rand, lb, ub)
11538 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11539 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_RK4
11540 : #endif
11541 : use pm_kind, only: RKC => RK4
11542 : real(RKC) , intent(out) :: rand
11543 : real(RKC) , intent(in) :: lb, ub
11544 : end subroutine
11545 : #endif
11546 :
11547 : #if RK3_ENABLED
11548 : impure elemental module subroutine setUnifRandRNGDLU_D0_RK3(rand, lb, ub)
11549 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11550 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_RK3
11551 : #endif
11552 : use pm_kind, only: RKC => RK3
11553 : real(RKC) , intent(out) :: rand
11554 : real(RKC) , intent(in) :: lb, ub
11555 : end subroutine
11556 : #endif
11557 :
11558 : #if RK2_ENABLED
11559 : impure elemental module subroutine setUnifRandRNGDLU_D0_RK2(rand, lb, ub)
11560 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11561 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_RK2
11562 : #endif
11563 : use pm_kind, only: RKC => RK2
11564 : real(RKC) , intent(out) :: rand
11565 : real(RKC) , intent(in) :: lb, ub
11566 : end subroutine
11567 : #endif
11568 :
11569 : #if RK1_ENABLED
11570 : impure elemental module subroutine setUnifRandRNGDLU_D0_RK1(rand, lb, ub)
11571 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11572 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGDLU_D0_RK1
11573 : #endif
11574 : use pm_kind, only: RKC => RK1
11575 : real(RKC) , intent(out) :: rand
11576 : real(RKC) , intent(in) :: lb, ub
11577 : end subroutine
11578 : #endif
11579 :
11580 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11581 :
11582 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11583 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11584 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11585 :
11586 : end interface
11587 :
11588 : ! RNGF
11589 :
11590 : interface setUnifRand
11591 :
11592 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11593 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11594 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11595 :
11596 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11597 :
11598 : #if SK5_ENABLED
11599 : impure elemental module subroutine setUnifRandRNGFDD_D0_SK5(rng, rand)
11600 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11601 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_SK5
11602 : #endif
11603 : use pm_kind, only: SKC => SK5
11604 : character(*,SKC) , intent(out) :: rand
11605 : type(rngf_type) , intent(in) :: rng
11606 : end subroutine
11607 : #endif
11608 :
11609 : #if SK4_ENABLED
11610 : impure elemental module subroutine setUnifRandRNGFDD_D0_SK4(rng, rand)
11611 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11612 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_SK4
11613 : #endif
11614 : use pm_kind, only: SKC => SK4
11615 : character(*,SKC) , intent(out) :: rand
11616 : type(rngf_type) , intent(in) :: rng
11617 : end subroutine
11618 : #endif
11619 :
11620 : #if SK3_ENABLED
11621 : impure elemental module subroutine setUnifRandRNGFDD_D0_SK3(rng, rand)
11622 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11623 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_SK3
11624 : #endif
11625 : use pm_kind, only: SKC => SK3
11626 : character(*,SKC) , intent(out) :: rand
11627 : type(rngf_type) , intent(in) :: rng
11628 : end subroutine
11629 : #endif
11630 :
11631 : #if SK2_ENABLED
11632 : impure elemental module subroutine setUnifRandRNGFDD_D0_SK2(rng, rand)
11633 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11634 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_SK2
11635 : #endif
11636 : use pm_kind, only: SKC => SK2
11637 : character(*,SKC) , intent(out) :: rand
11638 : type(rngf_type) , intent(in) :: rng
11639 : end subroutine
11640 : #endif
11641 :
11642 : #if SK1_ENABLED
11643 : impure elemental module subroutine setUnifRandRNGFDD_D0_SK1(rng, rand)
11644 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11645 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_SK1
11646 : #endif
11647 : use pm_kind, only: SKC => SK1
11648 : character(*,SKC) , intent(out) :: rand
11649 : type(rngf_type) , intent(in) :: rng
11650 : end subroutine
11651 : #endif
11652 :
11653 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11654 :
11655 : #if IK5_ENABLED
11656 : impure elemental module subroutine setUnifRandRNGFDD_D0_IK5(rng, rand)
11657 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11658 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_IK5
11659 : #endif
11660 : use pm_kind, only: IKC => IK5
11661 : integer(IKC) , intent(out) :: rand
11662 : type(rngf_type) , intent(in) :: rng
11663 : end subroutine
11664 : #endif
11665 :
11666 : #if IK4_ENABLED
11667 : impure elemental module subroutine setUnifRandRNGFDD_D0_IK4(rng, rand)
11668 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11669 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_IK4
11670 : #endif
11671 : use pm_kind, only: IKC => IK4
11672 : integer(IKC) , intent(out) :: rand
11673 : type(rngf_type) , intent(in) :: rng
11674 : end subroutine
11675 : #endif
11676 :
11677 : #if IK3_ENABLED
11678 : impure elemental module subroutine setUnifRandRNGFDD_D0_IK3(rng, rand)
11679 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11680 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_IK3
11681 : #endif
11682 : use pm_kind, only: IKC => IK3
11683 : integer(IKC) , intent(out) :: rand
11684 : type(rngf_type) , intent(in) :: rng
11685 : end subroutine
11686 : #endif
11687 :
11688 : #if IK2_ENABLED
11689 : impure elemental module subroutine setUnifRandRNGFDD_D0_IK2(rng, rand)
11690 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11691 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_IK2
11692 : #endif
11693 : use pm_kind, only: IKC => IK2
11694 : integer(IKC) , intent(out) :: rand
11695 : type(rngf_type) , intent(in) :: rng
11696 : end subroutine
11697 : #endif
11698 :
11699 : #if IK1_ENABLED
11700 : impure elemental module subroutine setUnifRandRNGFDD_D0_IK1(rng, rand)
11701 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11702 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_IK1
11703 : #endif
11704 : use pm_kind, only: IKC => IK1
11705 : integer(IKC) , intent(out) :: rand
11706 : type(rngf_type) , intent(in) :: rng
11707 : end subroutine
11708 : #endif
11709 :
11710 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11711 :
11712 : #if LK5_ENABLED
11713 : impure elemental module subroutine setUnifRandRNGFDD_D0_LK5(rng, rand)
11714 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11715 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_LK5
11716 : #endif
11717 : use pm_kind, only: LKC => LK5
11718 : logical(LKC) , intent(out) :: rand
11719 : type(rngf_type) , intent(in) :: rng
11720 : end subroutine
11721 : #endif
11722 :
11723 : #if LK4_ENABLED
11724 : impure elemental module subroutine setUnifRandRNGFDD_D0_LK4(rng, rand)
11725 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11726 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_LK4
11727 : #endif
11728 : use pm_kind, only: LKC => LK4
11729 : logical(LKC) , intent(out) :: rand
11730 : type(rngf_type) , intent(in) :: rng
11731 : end subroutine
11732 : #endif
11733 :
11734 : #if LK3_ENABLED
11735 : impure elemental module subroutine setUnifRandRNGFDD_D0_LK3(rng, rand)
11736 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11737 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_LK3
11738 : #endif
11739 : use pm_kind, only: LKC => LK3
11740 : logical(LKC) , intent(out) :: rand
11741 : type(rngf_type) , intent(in) :: rng
11742 : end subroutine
11743 : #endif
11744 :
11745 : #if LK2_ENABLED
11746 : impure elemental module subroutine setUnifRandRNGFDD_D0_LK2(rng, rand)
11747 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11748 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_LK2
11749 : #endif
11750 : use pm_kind, only: LKC => LK2
11751 : logical(LKC) , intent(out) :: rand
11752 : type(rngf_type) , intent(in) :: rng
11753 : end subroutine
11754 : #endif
11755 :
11756 : #if LK1_ENABLED
11757 : impure elemental module subroutine setUnifRandRNGFDD_D0_LK1(rng, rand)
11758 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11759 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_LK1
11760 : #endif
11761 : use pm_kind, only: LKC => LK1
11762 : logical(LKC) , intent(out) :: rand
11763 : type(rngf_type) , intent(in) :: rng
11764 : end subroutine
11765 : #endif
11766 :
11767 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11768 :
11769 : #if CK5_ENABLED
11770 : impure elemental module subroutine setUnifRandRNGFDD_D0_CK5(rng, rand)
11771 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11772 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_CK5
11773 : #endif
11774 : use pm_kind, only: CKC => CK5
11775 : complex(CKC) , intent(out) :: rand
11776 : type(rngf_type) , intent(in) :: rng
11777 : end subroutine
11778 : #endif
11779 :
11780 : #if CK4_ENABLED
11781 : impure elemental module subroutine setUnifRandRNGFDD_D0_CK4(rng, rand)
11782 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11783 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_CK4
11784 : #endif
11785 : use pm_kind, only: CKC => CK4
11786 : complex(CKC) , intent(out) :: rand
11787 : type(rngf_type) , intent(in) :: rng
11788 : end subroutine
11789 : #endif
11790 :
11791 : #if CK3_ENABLED
11792 : impure elemental module subroutine setUnifRandRNGFDD_D0_CK3(rng, rand)
11793 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11794 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_CK3
11795 : #endif
11796 : use pm_kind, only: CKC => CK3
11797 : complex(CKC) , intent(out) :: rand
11798 : type(rngf_type) , intent(in) :: rng
11799 : end subroutine
11800 : #endif
11801 :
11802 : #if CK2_ENABLED
11803 : impure elemental module subroutine setUnifRandRNGFDD_D0_CK2(rng, rand)
11804 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11805 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_CK2
11806 : #endif
11807 : use pm_kind, only: CKC => CK2
11808 : complex(CKC) , intent(out) :: rand
11809 : type(rngf_type) , intent(in) :: rng
11810 : end subroutine
11811 : #endif
11812 :
11813 : #if CK1_ENABLED
11814 : impure elemental module subroutine setUnifRandRNGFDD_D0_CK1(rng, rand)
11815 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11816 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_CK1
11817 : #endif
11818 : use pm_kind, only: CKC => CK1
11819 : complex(CKC) , intent(out) :: rand
11820 : type(rngf_type) , intent(in) :: rng
11821 : end subroutine
11822 : #endif
11823 :
11824 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11825 :
11826 : #if RK5_ENABLED
11827 : impure elemental module subroutine setUnifRandRNGFDD_D0_RK5(rng, rand)
11828 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11829 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_RK5
11830 : #endif
11831 : use pm_kind, only: RKC => RK5
11832 : real(RKC) , intent(out) :: rand
11833 : type(rngf_type) , intent(in) :: rng
11834 : end subroutine
11835 : #endif
11836 :
11837 : #if RK4_ENABLED
11838 : impure elemental module subroutine setUnifRandRNGFDD_D0_RK4(rng, rand)
11839 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11840 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_RK4
11841 : #endif
11842 : use pm_kind, only: RKC => RK4
11843 : real(RKC) , intent(out) :: rand
11844 : type(rngf_type) , intent(in) :: rng
11845 : end subroutine
11846 : #endif
11847 :
11848 : #if RK3_ENABLED
11849 : impure elemental module subroutine setUnifRandRNGFDD_D0_RK3(rng, rand)
11850 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11851 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_RK3
11852 : #endif
11853 : use pm_kind, only: RKC => RK3
11854 : real(RKC) , intent(out) :: rand
11855 : type(rngf_type) , intent(in) :: rng
11856 : end subroutine
11857 : #endif
11858 :
11859 : #if RK2_ENABLED
11860 : impure elemental module subroutine setUnifRandRNGFDD_D0_RK2(rng, rand)
11861 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11862 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_RK2
11863 : #endif
11864 : use pm_kind, only: RKC => RK2
11865 : real(RKC) , intent(out) :: rand
11866 : type(rngf_type) , intent(in) :: rng
11867 : end subroutine
11868 : #endif
11869 :
11870 : #if RK1_ENABLED
11871 : impure elemental module subroutine setUnifRandRNGFDD_D0_RK1(rng, rand)
11872 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11873 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFDD_D0_RK1
11874 : #endif
11875 : use pm_kind, only: RKC => RK1
11876 : real(RKC) , intent(out) :: rand
11877 : type(rngf_type) , intent(in) :: rng
11878 : end subroutine
11879 : #endif
11880 :
11881 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11882 :
11883 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11884 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11885 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11886 :
11887 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11888 :
11889 : #if SK5_ENABLED
11890 : impure elemental module subroutine setUnifRandRNGFLU_D0_SK5(rng, rand, lb, ub)
11891 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11892 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_SK5
11893 : #endif
11894 : use pm_kind, only: SKC => SK5
11895 : character(*,SKC) , intent(out) :: rand
11896 : character(*,SKC) , intent(in) :: lb, ub
11897 : type(rngf_type) , intent(in) :: rng
11898 : end subroutine
11899 : #endif
11900 :
11901 : #if SK4_ENABLED
11902 : impure elemental module subroutine setUnifRandRNGFLU_D0_SK4(rng, rand, lb, ub)
11903 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11904 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_SK4
11905 : #endif
11906 : use pm_kind, only: SKC => SK4
11907 : character(*,SKC) , intent(out) :: rand
11908 : character(*,SKC) , intent(in) :: lb, ub
11909 : type(rngf_type) , intent(in) :: rng
11910 : end subroutine
11911 : #endif
11912 :
11913 : #if SK3_ENABLED
11914 : impure elemental module subroutine setUnifRandRNGFLU_D0_SK3(rng, rand, lb, ub)
11915 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11916 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_SK3
11917 : #endif
11918 : use pm_kind, only: SKC => SK3
11919 : character(*,SKC) , intent(out) :: rand
11920 : character(*,SKC) , intent(in) :: lb, ub
11921 : type(rngf_type) , intent(in) :: rng
11922 : end subroutine
11923 : #endif
11924 :
11925 : #if SK2_ENABLED
11926 : impure elemental module subroutine setUnifRandRNGFLU_D0_SK2(rng, rand, lb, ub)
11927 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11928 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_SK2
11929 : #endif
11930 : use pm_kind, only: SKC => SK2
11931 : character(*,SKC) , intent(out) :: rand
11932 : character(*,SKC) , intent(in) :: lb, ub
11933 : type(rngf_type) , intent(in) :: rng
11934 : end subroutine
11935 : #endif
11936 :
11937 : #if SK1_ENABLED
11938 : impure elemental module subroutine setUnifRandRNGFLU_D0_SK1(rng, rand, lb, ub)
11939 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11940 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_SK1
11941 : #endif
11942 : use pm_kind, only: SKC => SK1
11943 : character(*,SKC) , intent(out) :: rand
11944 : character(*,SKC) , intent(in) :: lb, ub
11945 : type(rngf_type) , intent(in) :: rng
11946 : end subroutine
11947 : #endif
11948 :
11949 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
11950 :
11951 : #if IK5_ENABLED
11952 : impure elemental module subroutine setUnifRandRNGFLU_D0_IK5(rng, rand, lb, ub)
11953 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11954 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_IK5
11955 : #endif
11956 : use pm_kind, only: IKC => IK5
11957 : integer(IKC) , intent(out) :: rand
11958 : integer(IKC) , intent(in) :: lb, ub
11959 : type(rngf_type) , intent(in) :: rng
11960 : end subroutine
11961 : #endif
11962 :
11963 : #if IK4_ENABLED
11964 : impure elemental module subroutine setUnifRandRNGFLU_D0_IK4(rng, rand, lb, ub)
11965 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11966 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_IK4
11967 : #endif
11968 : use pm_kind, only: IKC => IK4
11969 : integer(IKC) , intent(out) :: rand
11970 : integer(IKC) , intent(in) :: lb, ub
11971 : type(rngf_type) , intent(in) :: rng
11972 : end subroutine
11973 : #endif
11974 :
11975 : #if IK3_ENABLED
11976 : impure elemental module subroutine setUnifRandRNGFLU_D0_IK3(rng, rand, lb, ub)
11977 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11978 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_IK3
11979 : #endif
11980 : use pm_kind, only: IKC => IK3
11981 : integer(IKC) , intent(out) :: rand
11982 : integer(IKC) , intent(in) :: lb, ub
11983 : type(rngf_type) , intent(in) :: rng
11984 : end subroutine
11985 : #endif
11986 :
11987 : #if IK2_ENABLED
11988 : impure elemental module subroutine setUnifRandRNGFLU_D0_IK2(rng, rand, lb, ub)
11989 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
11990 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_IK2
11991 : #endif
11992 : use pm_kind, only: IKC => IK2
11993 : integer(IKC) , intent(out) :: rand
11994 : integer(IKC) , intent(in) :: lb, ub
11995 : type(rngf_type) , intent(in) :: rng
11996 : end subroutine
11997 : #endif
11998 :
11999 : #if IK1_ENABLED
12000 : impure elemental module subroutine setUnifRandRNGFLU_D0_IK1(rng, rand, lb, ub)
12001 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12002 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_IK1
12003 : #endif
12004 : use pm_kind, only: IKC => IK1
12005 : integer(IKC) , intent(out) :: rand
12006 : integer(IKC) , intent(in) :: lb, ub
12007 : type(rngf_type) , intent(in) :: rng
12008 : end subroutine
12009 : #endif
12010 :
12011 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12012 :
12013 : #if LK5_ENABLED
12014 : impure elemental module subroutine setUnifRandRNGFLU_D0_LK5(rng, rand, lb, ub)
12015 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12016 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_LK5
12017 : #endif
12018 : use pm_kind, only: LKC => LK5
12019 : logical(LKC) , intent(out) :: rand
12020 : logical(LKC) , intent(in) :: lb, ub
12021 : type(rngf_type) , intent(in) :: rng
12022 : end subroutine
12023 : #endif
12024 :
12025 : #if LK4_ENABLED
12026 : impure elemental module subroutine setUnifRandRNGFLU_D0_LK4(rng, rand, lb, ub)
12027 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12028 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_LK4
12029 : #endif
12030 : use pm_kind, only: LKC => LK4
12031 : logical(LKC) , intent(out) :: rand
12032 : logical(LKC) , intent(in) :: lb, ub
12033 : type(rngf_type) , intent(in) :: rng
12034 : end subroutine
12035 : #endif
12036 :
12037 : #if LK3_ENABLED
12038 : impure elemental module subroutine setUnifRandRNGFLU_D0_LK3(rng, rand, lb, ub)
12039 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12040 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_LK3
12041 : #endif
12042 : use pm_kind, only: LKC => LK3
12043 : logical(LKC) , intent(out) :: rand
12044 : logical(LKC) , intent(in) :: lb, ub
12045 : type(rngf_type) , intent(in) :: rng
12046 : end subroutine
12047 : #endif
12048 :
12049 : #if LK2_ENABLED
12050 : impure elemental module subroutine setUnifRandRNGFLU_D0_LK2(rng, rand, lb, ub)
12051 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12052 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_LK2
12053 : #endif
12054 : use pm_kind, only: LKC => LK2
12055 : logical(LKC) , intent(out) :: rand
12056 : logical(LKC) , intent(in) :: lb, ub
12057 : type(rngf_type) , intent(in) :: rng
12058 : end subroutine
12059 : #endif
12060 :
12061 : #if LK1_ENABLED
12062 : impure elemental module subroutine setUnifRandRNGFLU_D0_LK1(rng, rand, lb, ub)
12063 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12064 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_LK1
12065 : #endif
12066 : use pm_kind, only: LKC => LK1
12067 : logical(LKC) , intent(out) :: rand
12068 : logical(LKC) , intent(in) :: lb, ub
12069 : type(rngf_type) , intent(in) :: rng
12070 : end subroutine
12071 : #endif
12072 :
12073 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12074 :
12075 : #if CK5_ENABLED
12076 : impure elemental module subroutine setUnifRandRNGFLU_D0_CK5(rng, rand, lb, ub)
12077 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12078 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_CK5
12079 : #endif
12080 : use pm_kind, only: CKC => CK5
12081 : complex(CKC) , intent(out) :: rand
12082 : complex(CKC) , intent(in) :: lb, ub
12083 : type(rngf_type) , intent(in) :: rng
12084 : end subroutine
12085 : #endif
12086 :
12087 : #if CK4_ENABLED
12088 : impure elemental module subroutine setUnifRandRNGFLU_D0_CK4(rng, rand, lb, ub)
12089 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12090 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_CK4
12091 : #endif
12092 : use pm_kind, only: CKC => CK4
12093 : complex(CKC) , intent(out) :: rand
12094 : complex(CKC) , intent(in) :: lb, ub
12095 : type(rngf_type) , intent(in) :: rng
12096 : end subroutine
12097 : #endif
12098 :
12099 : #if CK3_ENABLED
12100 : impure elemental module subroutine setUnifRandRNGFLU_D0_CK3(rng, rand, lb, ub)
12101 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12102 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_CK3
12103 : #endif
12104 : use pm_kind, only: CKC => CK3
12105 : complex(CKC) , intent(out) :: rand
12106 : complex(CKC) , intent(in) :: lb, ub
12107 : type(rngf_type) , intent(in) :: rng
12108 : end subroutine
12109 : #endif
12110 :
12111 : #if CK2_ENABLED
12112 : impure elemental module subroutine setUnifRandRNGFLU_D0_CK2(rng, rand, lb, ub)
12113 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12114 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_CK2
12115 : #endif
12116 : use pm_kind, only: CKC => CK2
12117 : complex(CKC) , intent(out) :: rand
12118 : complex(CKC) , intent(in) :: lb, ub
12119 : type(rngf_type) , intent(in) :: rng
12120 : end subroutine
12121 : #endif
12122 :
12123 : #if CK1_ENABLED
12124 : impure elemental module subroutine setUnifRandRNGFLU_D0_CK1(rng, rand, lb, ub)
12125 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12126 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_CK1
12127 : #endif
12128 : use pm_kind, only: CKC => CK1
12129 : complex(CKC) , intent(out) :: rand
12130 : complex(CKC) , intent(in) :: lb, ub
12131 : type(rngf_type) , intent(in) :: rng
12132 : end subroutine
12133 : #endif
12134 :
12135 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12136 :
12137 : #if RK5_ENABLED
12138 : impure elemental module subroutine setUnifRandRNGFLU_D0_RK5(rng, rand, lb, ub)
12139 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12140 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_RK5
12141 : #endif
12142 : use pm_kind, only: RKC => RK5
12143 : real(RKC) , intent(out) :: rand
12144 : real(RKC) , intent(in) :: lb, ub
12145 : type(rngf_type) , intent(in) :: rng
12146 : end subroutine
12147 : #endif
12148 :
12149 : #if RK4_ENABLED
12150 : impure elemental module subroutine setUnifRandRNGFLU_D0_RK4(rng, rand, lb, ub)
12151 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12152 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_RK4
12153 : #endif
12154 : use pm_kind, only: RKC => RK4
12155 : real(RKC) , intent(out) :: rand
12156 : real(RKC) , intent(in) :: lb, ub
12157 : type(rngf_type) , intent(in) :: rng
12158 : end subroutine
12159 : #endif
12160 :
12161 : #if RK3_ENABLED
12162 : impure elemental module subroutine setUnifRandRNGFLU_D0_RK3(rng, rand, lb, ub)
12163 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12164 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_RK3
12165 : #endif
12166 : use pm_kind, only: RKC => RK3
12167 : real(RKC) , intent(out) :: rand
12168 : real(RKC) , intent(in) :: lb, ub
12169 : type(rngf_type) , intent(in) :: rng
12170 : end subroutine
12171 : #endif
12172 :
12173 : #if RK2_ENABLED
12174 : impure elemental module subroutine setUnifRandRNGFLU_D0_RK2(rng, rand, lb, ub)
12175 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12176 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_RK2
12177 : #endif
12178 : use pm_kind, only: RKC => RK2
12179 : real(RKC) , intent(out) :: rand
12180 : real(RKC) , intent(in) :: lb, ub
12181 : type(rngf_type) , intent(in) :: rng
12182 : end subroutine
12183 : #endif
12184 :
12185 : #if RK1_ENABLED
12186 : impure elemental module subroutine setUnifRandRNGFLU_D0_RK1(rng, rand, lb, ub)
12187 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12188 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGFLU_D0_RK1
12189 : #endif
12190 : use pm_kind, only: RKC => RK1
12191 : real(RKC) , intent(out) :: rand
12192 : real(RKC) , intent(in) :: lb, ub
12193 : type(rngf_type) , intent(in) :: rng
12194 : end subroutine
12195 : #endif
12196 :
12197 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12198 :
12199 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12200 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12201 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12202 :
12203 : end interface
12204 :
12205 : ! RNGS
12206 :
12207 : interface setUnifRand
12208 :
12209 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12210 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12211 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12212 :
12213 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12214 :
12215 : #if SK5_ENABLED
12216 : PURE elemental module subroutine setUnifRandRNGSDD_D0_SK5(rng, rand)
12217 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12218 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_SK5
12219 : #endif
12220 : use pm_kind, only: SKC => SK5
12221 : character(*,SKC) , intent(out) :: rand
12222 : type(splitmix64_type) , intent(inout) :: rng
12223 : end subroutine
12224 : #endif
12225 :
12226 : #if SK4_ENABLED
12227 : PURE elemental module subroutine setUnifRandRNGSDD_D0_SK4(rng, rand)
12228 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12229 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_SK4
12230 : #endif
12231 : use pm_kind, only: SKC => SK4
12232 : character(*,SKC) , intent(out) :: rand
12233 : type(splitmix64_type) , intent(inout) :: rng
12234 : end subroutine
12235 : #endif
12236 :
12237 : #if SK3_ENABLED
12238 : PURE elemental module subroutine setUnifRandRNGSDD_D0_SK3(rng, rand)
12239 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12240 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_SK3
12241 : #endif
12242 : use pm_kind, only: SKC => SK3
12243 : character(*,SKC) , intent(out) :: rand
12244 : type(splitmix64_type) , intent(inout) :: rng
12245 : end subroutine
12246 : #endif
12247 :
12248 : #if SK2_ENABLED
12249 : PURE elemental module subroutine setUnifRandRNGSDD_D0_SK2(rng, rand)
12250 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12251 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_SK2
12252 : #endif
12253 : use pm_kind, only: SKC => SK2
12254 : character(*,SKC) , intent(out) :: rand
12255 : type(splitmix64_type) , intent(inout) :: rng
12256 : end subroutine
12257 : #endif
12258 :
12259 : #if SK1_ENABLED
12260 : PURE elemental module subroutine setUnifRandRNGSDD_D0_SK1(rng, rand)
12261 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12262 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_SK1
12263 : #endif
12264 : use pm_kind, only: SKC => SK1
12265 : character(*,SKC) , intent(out) :: rand
12266 : type(splitmix64_type) , intent(inout) :: rng
12267 : end subroutine
12268 : #endif
12269 :
12270 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12271 :
12272 : #if IK5_ENABLED
12273 : PURE elemental module subroutine setUnifRandRNGSDD_D0_IK5(rng, rand)
12274 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12275 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_IK5
12276 : #endif
12277 : use pm_kind, only: IKC => IK5
12278 : integer(IKC) , intent(out) :: rand
12279 : type(splitmix64_type) , intent(inout) :: rng
12280 : end subroutine
12281 : #endif
12282 :
12283 : #if IK4_ENABLED
12284 : PURE elemental module subroutine setUnifRandRNGSDD_D0_IK4(rng, rand)
12285 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12286 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_IK4
12287 : #endif
12288 : use pm_kind, only: IKC => IK4
12289 : integer(IKC) , intent(out) :: rand
12290 : type(splitmix64_type) , intent(inout) :: rng
12291 : end subroutine
12292 : #endif
12293 :
12294 : #if IK3_ENABLED
12295 : PURE elemental module subroutine setUnifRandRNGSDD_D0_IK3(rng, rand)
12296 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12297 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_IK3
12298 : #endif
12299 : use pm_kind, only: IKC => IK3
12300 : integer(IKC) , intent(out) :: rand
12301 : type(splitmix64_type) , intent(inout) :: rng
12302 : end subroutine
12303 : #endif
12304 :
12305 : #if IK2_ENABLED
12306 : PURE elemental module subroutine setUnifRandRNGSDD_D0_IK2(rng, rand)
12307 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12308 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_IK2
12309 : #endif
12310 : use pm_kind, only: IKC => IK2
12311 : integer(IKC) , intent(out) :: rand
12312 : type(splitmix64_type) , intent(inout) :: rng
12313 : end subroutine
12314 : #endif
12315 :
12316 : #if IK1_ENABLED
12317 : PURE elemental module subroutine setUnifRandRNGSDD_D0_IK1(rng, rand)
12318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12319 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_IK1
12320 : #endif
12321 : use pm_kind, only: IKC => IK1
12322 : integer(IKC) , intent(out) :: rand
12323 : type(splitmix64_type) , intent(inout) :: rng
12324 : end subroutine
12325 : #endif
12326 :
12327 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12328 :
12329 : #if LK5_ENABLED
12330 : PURE elemental module subroutine setUnifRandRNGSDD_D0_LK5(rng, rand)
12331 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12332 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_LK5
12333 : #endif
12334 : use pm_kind, only: LKC => LK5
12335 : logical(LKC) , intent(out) :: rand
12336 : type(splitmix64_type) , intent(inout) :: rng
12337 : end subroutine
12338 : #endif
12339 :
12340 : #if LK4_ENABLED
12341 : PURE elemental module subroutine setUnifRandRNGSDD_D0_LK4(rng, rand)
12342 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12343 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_LK4
12344 : #endif
12345 : use pm_kind, only: LKC => LK4
12346 : logical(LKC) , intent(out) :: rand
12347 : type(splitmix64_type) , intent(inout) :: rng
12348 : end subroutine
12349 : #endif
12350 :
12351 : #if LK3_ENABLED
12352 : PURE elemental module subroutine setUnifRandRNGSDD_D0_LK3(rng, rand)
12353 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12354 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_LK3
12355 : #endif
12356 : use pm_kind, only: LKC => LK3
12357 : logical(LKC) , intent(out) :: rand
12358 : type(splitmix64_type) , intent(inout) :: rng
12359 : end subroutine
12360 : #endif
12361 :
12362 : #if LK2_ENABLED
12363 : PURE elemental module subroutine setUnifRandRNGSDD_D0_LK2(rng, rand)
12364 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12365 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_LK2
12366 : #endif
12367 : use pm_kind, only: LKC => LK2
12368 : logical(LKC) , intent(out) :: rand
12369 : type(splitmix64_type) , intent(inout) :: rng
12370 : end subroutine
12371 : #endif
12372 :
12373 : #if LK1_ENABLED
12374 : PURE elemental module subroutine setUnifRandRNGSDD_D0_LK1(rng, rand)
12375 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12376 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_LK1
12377 : #endif
12378 : use pm_kind, only: LKC => LK1
12379 : logical(LKC) , intent(out) :: rand
12380 : type(splitmix64_type) , intent(inout) :: rng
12381 : end subroutine
12382 : #endif
12383 :
12384 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12385 :
12386 : #if CK5_ENABLED
12387 : PURE elemental module subroutine setUnifRandRNGSDD_D0_CK5(rng, rand)
12388 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12389 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_CK5
12390 : #endif
12391 : use pm_kind, only: CKC => CK5
12392 : complex(CKC) , intent(out) :: rand
12393 : type(splitmix64_type) , intent(inout) :: rng
12394 : end subroutine
12395 : #endif
12396 :
12397 : #if CK4_ENABLED
12398 : PURE elemental module subroutine setUnifRandRNGSDD_D0_CK4(rng, rand)
12399 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12400 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_CK4
12401 : #endif
12402 : use pm_kind, only: CKC => CK4
12403 : complex(CKC) , intent(out) :: rand
12404 : type(splitmix64_type) , intent(inout) :: rng
12405 : end subroutine
12406 : #endif
12407 :
12408 : #if CK3_ENABLED
12409 : PURE elemental module subroutine setUnifRandRNGSDD_D0_CK3(rng, rand)
12410 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12411 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_CK3
12412 : #endif
12413 : use pm_kind, only: CKC => CK3
12414 : complex(CKC) , intent(out) :: rand
12415 : type(splitmix64_type) , intent(inout) :: rng
12416 : end subroutine
12417 : #endif
12418 :
12419 : #if CK2_ENABLED
12420 : PURE elemental module subroutine setUnifRandRNGSDD_D0_CK2(rng, rand)
12421 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12422 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_CK2
12423 : #endif
12424 : use pm_kind, only: CKC => CK2
12425 : complex(CKC) , intent(out) :: rand
12426 : type(splitmix64_type) , intent(inout) :: rng
12427 : end subroutine
12428 : #endif
12429 :
12430 : #if CK1_ENABLED
12431 : PURE elemental module subroutine setUnifRandRNGSDD_D0_CK1(rng, rand)
12432 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12433 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_CK1
12434 : #endif
12435 : use pm_kind, only: CKC => CK1
12436 : complex(CKC) , intent(out) :: rand
12437 : type(splitmix64_type) , intent(inout) :: rng
12438 : end subroutine
12439 : #endif
12440 :
12441 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12442 :
12443 : #if RK5_ENABLED
12444 : PURE elemental module subroutine setUnifRandRNGSDD_D0_RK5(rng, rand)
12445 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12446 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_RK5
12447 : #endif
12448 : use pm_kind, only: RKC => RK5
12449 : real(RKC) , intent(out) :: rand
12450 : type(splitmix64_type) , intent(inout) :: rng
12451 : end subroutine
12452 : #endif
12453 :
12454 : #if RK4_ENABLED
12455 : PURE elemental module subroutine setUnifRandRNGSDD_D0_RK4(rng, rand)
12456 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12457 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_RK4
12458 : #endif
12459 : use pm_kind, only: RKC => RK4
12460 : real(RKC) , intent(out) :: rand
12461 : type(splitmix64_type) , intent(inout) :: rng
12462 : end subroutine
12463 : #endif
12464 :
12465 : #if RK3_ENABLED
12466 : PURE elemental module subroutine setUnifRandRNGSDD_D0_RK3(rng, rand)
12467 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12468 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_RK3
12469 : #endif
12470 : use pm_kind, only: RKC => RK3
12471 : real(RKC) , intent(out) :: rand
12472 : type(splitmix64_type) , intent(inout) :: rng
12473 : end subroutine
12474 : #endif
12475 :
12476 : #if RK2_ENABLED
12477 : PURE elemental module subroutine setUnifRandRNGSDD_D0_RK2(rng, rand)
12478 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12479 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_RK2
12480 : #endif
12481 : use pm_kind, only: RKC => RK2
12482 : real(RKC) , intent(out) :: rand
12483 : type(splitmix64_type) , intent(inout) :: rng
12484 : end subroutine
12485 : #endif
12486 :
12487 : #if RK1_ENABLED
12488 : PURE elemental module subroutine setUnifRandRNGSDD_D0_RK1(rng, rand)
12489 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12490 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D0_RK1
12491 : #endif
12492 : use pm_kind, only: RKC => RK1
12493 : real(RKC) , intent(out) :: rand
12494 : type(splitmix64_type) , intent(inout) :: rng
12495 : end subroutine
12496 : #endif
12497 :
12498 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12499 :
12500 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12501 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12502 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12503 :
12504 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12505 :
12506 : #if SK5_ENABLED
12507 : PURE elemental module subroutine setUnifRandRNGSLU_D0_SK5(rng, rand, lb, ub)
12508 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12509 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_SK5
12510 : #endif
12511 : use pm_kind, only: SKC => SK5
12512 : character(*,SKC) , intent(out) :: rand
12513 : character(*,SKC) , intent(in) :: lb, ub
12514 : type(splitmix64_type) , intent(inout) :: rng
12515 : end subroutine
12516 : #endif
12517 :
12518 : #if SK4_ENABLED
12519 : PURE elemental module subroutine setUnifRandRNGSLU_D0_SK4(rng, rand, lb, ub)
12520 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12521 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_SK4
12522 : #endif
12523 : use pm_kind, only: SKC => SK4
12524 : character(*,SKC) , intent(out) :: rand
12525 : character(*,SKC) , intent(in) :: lb, ub
12526 : type(splitmix64_type) , intent(inout) :: rng
12527 : end subroutine
12528 : #endif
12529 :
12530 : #if SK3_ENABLED
12531 : PURE elemental module subroutine setUnifRandRNGSLU_D0_SK3(rng, rand, lb, ub)
12532 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12533 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_SK3
12534 : #endif
12535 : use pm_kind, only: SKC => SK3
12536 : character(*,SKC) , intent(out) :: rand
12537 : character(*,SKC) , intent(in) :: lb, ub
12538 : type(splitmix64_type) , intent(inout) :: rng
12539 : end subroutine
12540 : #endif
12541 :
12542 : #if SK2_ENABLED
12543 : PURE elemental module subroutine setUnifRandRNGSLU_D0_SK2(rng, rand, lb, ub)
12544 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12545 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_SK2
12546 : #endif
12547 : use pm_kind, only: SKC => SK2
12548 : character(*,SKC) , intent(out) :: rand
12549 : character(*,SKC) , intent(in) :: lb, ub
12550 : type(splitmix64_type) , intent(inout) :: rng
12551 : end subroutine
12552 : #endif
12553 :
12554 : #if SK1_ENABLED
12555 : PURE elemental module subroutine setUnifRandRNGSLU_D0_SK1(rng, rand, lb, ub)
12556 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12557 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_SK1
12558 : #endif
12559 : use pm_kind, only: SKC => SK1
12560 : character(*,SKC) , intent(out) :: rand
12561 : character(*,SKC) , intent(in) :: lb, ub
12562 : type(splitmix64_type) , intent(inout) :: rng
12563 : end subroutine
12564 : #endif
12565 :
12566 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12567 :
12568 : #if IK5_ENABLED
12569 : PURE elemental module subroutine setUnifRandRNGSLU_D0_IK5(rng, rand, lb, ub)
12570 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12571 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_IK5
12572 : #endif
12573 : use pm_kind, only: IKC => IK5
12574 : integer(IKC) , intent(out) :: rand
12575 : integer(IKC) , intent(in) :: lb, ub
12576 : type(splitmix64_type) , intent(inout) :: rng
12577 : end subroutine
12578 : #endif
12579 :
12580 : #if IK4_ENABLED
12581 : PURE elemental module subroutine setUnifRandRNGSLU_D0_IK4(rng, rand, lb, ub)
12582 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12583 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_IK4
12584 : #endif
12585 : use pm_kind, only: IKC => IK4
12586 : integer(IKC) , intent(out) :: rand
12587 : integer(IKC) , intent(in) :: lb, ub
12588 : type(splitmix64_type) , intent(inout) :: rng
12589 : end subroutine
12590 : #endif
12591 :
12592 : #if IK3_ENABLED
12593 : PURE elemental module subroutine setUnifRandRNGSLU_D0_IK3(rng, rand, lb, ub)
12594 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12595 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_IK3
12596 : #endif
12597 : use pm_kind, only: IKC => IK3
12598 : integer(IKC) , intent(out) :: rand
12599 : integer(IKC) , intent(in) :: lb, ub
12600 : type(splitmix64_type) , intent(inout) :: rng
12601 : end subroutine
12602 : #endif
12603 :
12604 : #if IK2_ENABLED
12605 : PURE elemental module subroutine setUnifRandRNGSLU_D0_IK2(rng, rand, lb, ub)
12606 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12607 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_IK2
12608 : #endif
12609 : use pm_kind, only: IKC => IK2
12610 : integer(IKC) , intent(out) :: rand
12611 : integer(IKC) , intent(in) :: lb, ub
12612 : type(splitmix64_type) , intent(inout) :: rng
12613 : end subroutine
12614 : #endif
12615 :
12616 : #if IK1_ENABLED
12617 : PURE elemental module subroutine setUnifRandRNGSLU_D0_IK1(rng, rand, lb, ub)
12618 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12619 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_IK1
12620 : #endif
12621 : use pm_kind, only: IKC => IK1
12622 : integer(IKC) , intent(out) :: rand
12623 : integer(IKC) , intent(in) :: lb, ub
12624 : type(splitmix64_type) , intent(inout) :: rng
12625 : end subroutine
12626 : #endif
12627 :
12628 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12629 :
12630 : #if LK5_ENABLED
12631 : PURE elemental module subroutine setUnifRandRNGSLU_D0_LK5(rng, rand, lb, ub)
12632 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12633 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_LK5
12634 : #endif
12635 : use pm_kind, only: LKC => LK5
12636 : logical(LKC) , intent(out) :: rand
12637 : logical(LKC) , intent(in) :: lb, ub
12638 : type(splitmix64_type) , intent(inout) :: rng
12639 : end subroutine
12640 : #endif
12641 :
12642 : #if LK4_ENABLED
12643 : PURE elemental module subroutine setUnifRandRNGSLU_D0_LK4(rng, rand, lb, ub)
12644 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12645 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_LK4
12646 : #endif
12647 : use pm_kind, only: LKC => LK4
12648 : logical(LKC) , intent(out) :: rand
12649 : logical(LKC) , intent(in) :: lb, ub
12650 : type(splitmix64_type) , intent(inout) :: rng
12651 : end subroutine
12652 : #endif
12653 :
12654 : #if LK3_ENABLED
12655 : PURE elemental module subroutine setUnifRandRNGSLU_D0_LK3(rng, rand, lb, ub)
12656 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12657 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_LK3
12658 : #endif
12659 : use pm_kind, only: LKC => LK3
12660 : logical(LKC) , intent(out) :: rand
12661 : logical(LKC) , intent(in) :: lb, ub
12662 : type(splitmix64_type) , intent(inout) :: rng
12663 : end subroutine
12664 : #endif
12665 :
12666 : #if LK2_ENABLED
12667 : PURE elemental module subroutine setUnifRandRNGSLU_D0_LK2(rng, rand, lb, ub)
12668 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12669 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_LK2
12670 : #endif
12671 : use pm_kind, only: LKC => LK2
12672 : logical(LKC) , intent(out) :: rand
12673 : logical(LKC) , intent(in) :: lb, ub
12674 : type(splitmix64_type) , intent(inout) :: rng
12675 : end subroutine
12676 : #endif
12677 :
12678 : #if LK1_ENABLED
12679 : PURE elemental module subroutine setUnifRandRNGSLU_D0_LK1(rng, rand, lb, ub)
12680 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12681 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_LK1
12682 : #endif
12683 : use pm_kind, only: LKC => LK1
12684 : logical(LKC) , intent(out) :: rand
12685 : logical(LKC) , intent(in) :: lb, ub
12686 : type(splitmix64_type) , intent(inout) :: rng
12687 : end subroutine
12688 : #endif
12689 :
12690 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12691 :
12692 : #if CK5_ENABLED
12693 : PURE elemental module subroutine setUnifRandRNGSLU_D0_CK5(rng, rand, lb, ub)
12694 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12695 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_CK5
12696 : #endif
12697 : use pm_kind, only: CKC => CK5
12698 : complex(CKC) , intent(out) :: rand
12699 : complex(CKC) , intent(in) :: lb, ub
12700 : type(splitmix64_type) , intent(inout) :: rng
12701 : end subroutine
12702 : #endif
12703 :
12704 : #if CK4_ENABLED
12705 : PURE elemental module subroutine setUnifRandRNGSLU_D0_CK4(rng, rand, lb, ub)
12706 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12707 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_CK4
12708 : #endif
12709 : use pm_kind, only: CKC => CK4
12710 : complex(CKC) , intent(out) :: rand
12711 : complex(CKC) , intent(in) :: lb, ub
12712 : type(splitmix64_type) , intent(inout) :: rng
12713 : end subroutine
12714 : #endif
12715 :
12716 : #if CK3_ENABLED
12717 : PURE elemental module subroutine setUnifRandRNGSLU_D0_CK3(rng, rand, lb, ub)
12718 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12719 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_CK3
12720 : #endif
12721 : use pm_kind, only: CKC => CK3
12722 : complex(CKC) , intent(out) :: rand
12723 : complex(CKC) , intent(in) :: lb, ub
12724 : type(splitmix64_type) , intent(inout) :: rng
12725 : end subroutine
12726 : #endif
12727 :
12728 : #if CK2_ENABLED
12729 : PURE elemental module subroutine setUnifRandRNGSLU_D0_CK2(rng, rand, lb, ub)
12730 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12731 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_CK2
12732 : #endif
12733 : use pm_kind, only: CKC => CK2
12734 : complex(CKC) , intent(out) :: rand
12735 : complex(CKC) , intent(in) :: lb, ub
12736 : type(splitmix64_type) , intent(inout) :: rng
12737 : end subroutine
12738 : #endif
12739 :
12740 : #if CK1_ENABLED
12741 : PURE elemental module subroutine setUnifRandRNGSLU_D0_CK1(rng, rand, lb, ub)
12742 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12743 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_CK1
12744 : #endif
12745 : use pm_kind, only: CKC => CK1
12746 : complex(CKC) , intent(out) :: rand
12747 : complex(CKC) , intent(in) :: lb, ub
12748 : type(splitmix64_type) , intent(inout) :: rng
12749 : end subroutine
12750 : #endif
12751 :
12752 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12753 :
12754 : #if RK5_ENABLED
12755 : PURE elemental module subroutine setUnifRandRNGSLU_D0_RK5(rng, rand, lb, ub)
12756 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12757 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_RK5
12758 : #endif
12759 : use pm_kind, only: RKC => RK5
12760 : real(RKC) , intent(out) :: rand
12761 : real(RKC) , intent(in) :: lb, ub
12762 : type(splitmix64_type) , intent(inout) :: rng
12763 : end subroutine
12764 : #endif
12765 :
12766 : #if RK4_ENABLED
12767 : PURE elemental module subroutine setUnifRandRNGSLU_D0_RK4(rng, rand, lb, ub)
12768 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12769 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_RK4
12770 : #endif
12771 : use pm_kind, only: RKC => RK4
12772 : real(RKC) , intent(out) :: rand
12773 : real(RKC) , intent(in) :: lb, ub
12774 : type(splitmix64_type) , intent(inout) :: rng
12775 : end subroutine
12776 : #endif
12777 :
12778 : #if RK3_ENABLED
12779 : PURE elemental module subroutine setUnifRandRNGSLU_D0_RK3(rng, rand, lb, ub)
12780 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12781 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_RK3
12782 : #endif
12783 : use pm_kind, only: RKC => RK3
12784 : real(RKC) , intent(out) :: rand
12785 : real(RKC) , intent(in) :: lb, ub
12786 : type(splitmix64_type) , intent(inout) :: rng
12787 : end subroutine
12788 : #endif
12789 :
12790 : #if RK2_ENABLED
12791 : PURE elemental module subroutine setUnifRandRNGSLU_D0_RK2(rng, rand, lb, ub)
12792 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12793 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_RK2
12794 : #endif
12795 : use pm_kind, only: RKC => RK2
12796 : real(RKC) , intent(out) :: rand
12797 : real(RKC) , intent(in) :: lb, ub
12798 : type(splitmix64_type) , intent(inout) :: rng
12799 : end subroutine
12800 : #endif
12801 :
12802 : #if RK1_ENABLED
12803 : PURE elemental module subroutine setUnifRandRNGSLU_D0_RK1(rng, rand, lb, ub)
12804 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12805 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D0_RK1
12806 : #endif
12807 : use pm_kind, only: RKC => RK1
12808 : real(RKC) , intent(out) :: rand
12809 : real(RKC) , intent(in) :: lb, ub
12810 : type(splitmix64_type) , intent(inout) :: rng
12811 : end subroutine
12812 : #endif
12813 :
12814 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12815 :
12816 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12817 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12818 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12819 :
12820 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12821 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12822 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12823 :
12824 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12825 :
12826 : #if SK5_ENABLED
12827 : PURE module subroutine setUnifRandRNGSDD_D1_SK5(rng, rand)
12828 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12829 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_SK5
12830 : #endif
12831 : use pm_kind, only: SKC => SK5
12832 : character(*,SKC) , intent(out) :: rand(:)
12833 : type(splitmix64_type) , intent(inout) :: rng
12834 : end subroutine
12835 : #endif
12836 :
12837 : #if SK4_ENABLED
12838 : PURE module subroutine setUnifRandRNGSDD_D1_SK4(rng, rand)
12839 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12840 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_SK4
12841 : #endif
12842 : use pm_kind, only: SKC => SK4
12843 : character(*,SKC) , intent(out) :: rand(:)
12844 : type(splitmix64_type) , intent(inout) :: rng
12845 : end subroutine
12846 : #endif
12847 :
12848 : #if SK3_ENABLED
12849 : PURE module subroutine setUnifRandRNGSDD_D1_SK3(rng, rand)
12850 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12851 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_SK3
12852 : #endif
12853 : use pm_kind, only: SKC => SK3
12854 : character(*,SKC) , intent(out) :: rand(:)
12855 : type(splitmix64_type) , intent(inout) :: rng
12856 : end subroutine
12857 : #endif
12858 :
12859 : #if SK2_ENABLED
12860 : PURE module subroutine setUnifRandRNGSDD_D1_SK2(rng, rand)
12861 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12862 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_SK2
12863 : #endif
12864 : use pm_kind, only: SKC => SK2
12865 : character(*,SKC) , intent(out) :: rand(:)
12866 : type(splitmix64_type) , intent(inout) :: rng
12867 : end subroutine
12868 : #endif
12869 :
12870 : #if SK1_ENABLED
12871 : PURE module subroutine setUnifRandRNGSDD_D1_SK1(rng, rand)
12872 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12873 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_SK1
12874 : #endif
12875 : use pm_kind, only: SKC => SK1
12876 : character(*,SKC) , intent(out) :: rand(:)
12877 : type(splitmix64_type) , intent(inout) :: rng
12878 : end subroutine
12879 : #endif
12880 :
12881 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12882 :
12883 : #if IK5_ENABLED
12884 : PURE module subroutine setUnifRandRNGSDD_D1_IK5(rng, rand)
12885 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12886 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_IK5
12887 : #endif
12888 : use pm_kind, only: IKC => IK5
12889 : integer(IKC) , intent(out) :: rand(:)
12890 : type(splitmix64_type) , intent(inout) :: rng
12891 : end subroutine
12892 : #endif
12893 :
12894 : #if IK4_ENABLED
12895 : PURE module subroutine setUnifRandRNGSDD_D1_IK4(rng, rand)
12896 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12897 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_IK4
12898 : #endif
12899 : use pm_kind, only: IKC => IK4
12900 : integer(IKC) , intent(out) :: rand(:)
12901 : type(splitmix64_type) , intent(inout) :: rng
12902 : end subroutine
12903 : #endif
12904 :
12905 : #if IK3_ENABLED
12906 : PURE module subroutine setUnifRandRNGSDD_D1_IK3(rng, rand)
12907 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12908 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_IK3
12909 : #endif
12910 : use pm_kind, only: IKC => IK3
12911 : integer(IKC) , intent(out) :: rand(:)
12912 : type(splitmix64_type) , intent(inout) :: rng
12913 : end subroutine
12914 : #endif
12915 :
12916 : #if IK2_ENABLED
12917 : PURE module subroutine setUnifRandRNGSDD_D1_IK2(rng, rand)
12918 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12919 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_IK2
12920 : #endif
12921 : use pm_kind, only: IKC => IK2
12922 : integer(IKC) , intent(out) :: rand(:)
12923 : type(splitmix64_type) , intent(inout) :: rng
12924 : end subroutine
12925 : #endif
12926 :
12927 : #if IK1_ENABLED
12928 : PURE module subroutine setUnifRandRNGSDD_D1_IK1(rng, rand)
12929 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12930 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_IK1
12931 : #endif
12932 : use pm_kind, only: IKC => IK1
12933 : integer(IKC) , intent(out) :: rand(:)
12934 : type(splitmix64_type) , intent(inout) :: rng
12935 : end subroutine
12936 : #endif
12937 :
12938 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12939 :
12940 : #if LK5_ENABLED
12941 : PURE module subroutine setUnifRandRNGSDD_D1_LK5(rng, rand)
12942 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12943 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_LK5
12944 : #endif
12945 : use pm_kind, only: LKC => LK5
12946 : logical(LKC) , intent(out) :: rand(:)
12947 : type(splitmix64_type) , intent(inout) :: rng
12948 : end subroutine
12949 : #endif
12950 :
12951 : #if LK4_ENABLED
12952 : PURE module subroutine setUnifRandRNGSDD_D1_LK4(rng, rand)
12953 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12954 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_LK4
12955 : #endif
12956 : use pm_kind, only: LKC => LK4
12957 : logical(LKC) , intent(out) :: rand(:)
12958 : type(splitmix64_type) , intent(inout) :: rng
12959 : end subroutine
12960 : #endif
12961 :
12962 : #if LK3_ENABLED
12963 : PURE module subroutine setUnifRandRNGSDD_D1_LK3(rng, rand)
12964 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12965 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_LK3
12966 : #endif
12967 : use pm_kind, only: LKC => LK3
12968 : logical(LKC) , intent(out) :: rand(:)
12969 : type(splitmix64_type) , intent(inout) :: rng
12970 : end subroutine
12971 : #endif
12972 :
12973 : #if LK2_ENABLED
12974 : PURE module subroutine setUnifRandRNGSDD_D1_LK2(rng, rand)
12975 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12976 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_LK2
12977 : #endif
12978 : use pm_kind, only: LKC => LK2
12979 : logical(LKC) , intent(out) :: rand(:)
12980 : type(splitmix64_type) , intent(inout) :: rng
12981 : end subroutine
12982 : #endif
12983 :
12984 : #if LK1_ENABLED
12985 : PURE module subroutine setUnifRandRNGSDD_D1_LK1(rng, rand)
12986 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
12987 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_LK1
12988 : #endif
12989 : use pm_kind, only: LKC => LK1
12990 : logical(LKC) , intent(out) :: rand(:)
12991 : type(splitmix64_type) , intent(inout) :: rng
12992 : end subroutine
12993 : #endif
12994 :
12995 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
12996 :
12997 : #if CK5_ENABLED
12998 : PURE module subroutine setUnifRandRNGSDD_D1_CK5(rng, rand)
12999 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13000 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_CK5
13001 : #endif
13002 : use pm_kind, only: CKC => CK5
13003 : complex(CKC) , intent(out) :: rand(:)
13004 : type(splitmix64_type) , intent(inout) :: rng
13005 : end subroutine
13006 : #endif
13007 :
13008 : #if CK4_ENABLED
13009 : PURE module subroutine setUnifRandRNGSDD_D1_CK4(rng, rand)
13010 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13011 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_CK4
13012 : #endif
13013 : use pm_kind, only: CKC => CK4
13014 : complex(CKC) , intent(out) :: rand(:)
13015 : type(splitmix64_type) , intent(inout) :: rng
13016 : end subroutine
13017 : #endif
13018 :
13019 : #if CK3_ENABLED
13020 : PURE module subroutine setUnifRandRNGSDD_D1_CK3(rng, rand)
13021 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13022 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_CK3
13023 : #endif
13024 : use pm_kind, only: CKC => CK3
13025 : complex(CKC) , intent(out) :: rand(:)
13026 : type(splitmix64_type) , intent(inout) :: rng
13027 : end subroutine
13028 : #endif
13029 :
13030 : #if CK2_ENABLED
13031 : PURE module subroutine setUnifRandRNGSDD_D1_CK2(rng, rand)
13032 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13033 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_CK2
13034 : #endif
13035 : use pm_kind, only: CKC => CK2
13036 : complex(CKC) , intent(out) :: rand(:)
13037 : type(splitmix64_type) , intent(inout) :: rng
13038 : end subroutine
13039 : #endif
13040 :
13041 : #if CK1_ENABLED
13042 : PURE module subroutine setUnifRandRNGSDD_D1_CK1(rng, rand)
13043 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13044 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_CK1
13045 : #endif
13046 : use pm_kind, only: CKC => CK1
13047 : complex(CKC) , intent(out) :: rand(:)
13048 : type(splitmix64_type) , intent(inout) :: rng
13049 : end subroutine
13050 : #endif
13051 :
13052 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13053 :
13054 : #if RK5_ENABLED
13055 : PURE module subroutine setUnifRandRNGSDD_D1_RK5(rng, rand)
13056 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13057 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_RK5
13058 : #endif
13059 : use pm_kind, only: RKC => RK5
13060 : real(RKC) , intent(out) :: rand(:)
13061 : type(splitmix64_type) , intent(inout) :: rng
13062 : end subroutine
13063 : #endif
13064 :
13065 : #if RK4_ENABLED
13066 : PURE module subroutine setUnifRandRNGSDD_D1_RK4(rng, rand)
13067 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13068 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_RK4
13069 : #endif
13070 : use pm_kind, only: RKC => RK4
13071 : real(RKC) , intent(out) :: rand(:)
13072 : type(splitmix64_type) , intent(inout) :: rng
13073 : end subroutine
13074 : #endif
13075 :
13076 : #if RK3_ENABLED
13077 : PURE module subroutine setUnifRandRNGSDD_D1_RK3(rng, rand)
13078 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13079 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_RK3
13080 : #endif
13081 : use pm_kind, only: RKC => RK3
13082 : real(RKC) , intent(out) :: rand(:)
13083 : type(splitmix64_type) , intent(inout) :: rng
13084 : end subroutine
13085 : #endif
13086 :
13087 : #if RK2_ENABLED
13088 : PURE module subroutine setUnifRandRNGSDD_D1_RK2(rng, rand)
13089 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13090 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_RK2
13091 : #endif
13092 : use pm_kind, only: RKC => RK2
13093 : real(RKC) , intent(out) :: rand(:)
13094 : type(splitmix64_type) , intent(inout) :: rng
13095 : end subroutine
13096 : #endif
13097 :
13098 : #if RK1_ENABLED
13099 : PURE module subroutine setUnifRandRNGSDD_D1_RK1(rng, rand)
13100 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13101 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D1_RK1
13102 : #endif
13103 : use pm_kind, only: RKC => RK1
13104 : real(RKC) , intent(out) :: rand(:)
13105 : type(splitmix64_type) , intent(inout) :: rng
13106 : end subroutine
13107 : #endif
13108 :
13109 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13110 :
13111 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13112 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13113 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13114 :
13115 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13116 :
13117 : #if SK5_ENABLED
13118 : PURE module subroutine setUnifRandRNGSLU_D1_SK5(rng, rand, lb, ub)
13119 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13120 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_SK5
13121 : #endif
13122 : use pm_kind, only: SKC => SK5
13123 : character(*,SKC) , intent(out) :: rand(:)
13124 : character(*,SKC) , intent(in) :: lb, ub
13125 : type(splitmix64_type) , intent(inout) :: rng
13126 : end subroutine
13127 : #endif
13128 :
13129 : #if SK4_ENABLED
13130 : PURE module subroutine setUnifRandRNGSLU_D1_SK4(rng, rand, lb, ub)
13131 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13132 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_SK4
13133 : #endif
13134 : use pm_kind, only: SKC => SK4
13135 : character(*,SKC) , intent(out) :: rand(:)
13136 : character(*,SKC) , intent(in) :: lb, ub
13137 : type(splitmix64_type) , intent(inout) :: rng
13138 : end subroutine
13139 : #endif
13140 :
13141 : #if SK3_ENABLED
13142 : PURE module subroutine setUnifRandRNGSLU_D1_SK3(rng, rand, lb, ub)
13143 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13144 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_SK3
13145 : #endif
13146 : use pm_kind, only: SKC => SK3
13147 : character(*,SKC) , intent(out) :: rand(:)
13148 : character(*,SKC) , intent(in) :: lb, ub
13149 : type(splitmix64_type) , intent(inout) :: rng
13150 : end subroutine
13151 : #endif
13152 :
13153 : #if SK2_ENABLED
13154 : PURE module subroutine setUnifRandRNGSLU_D1_SK2(rng, rand, lb, ub)
13155 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13156 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_SK2
13157 : #endif
13158 : use pm_kind, only: SKC => SK2
13159 : character(*,SKC) , intent(out) :: rand(:)
13160 : character(*,SKC) , intent(in) :: lb, ub
13161 : type(splitmix64_type) , intent(inout) :: rng
13162 : end subroutine
13163 : #endif
13164 :
13165 : #if SK1_ENABLED
13166 : PURE module subroutine setUnifRandRNGSLU_D1_SK1(rng, rand, lb, ub)
13167 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13168 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_SK1
13169 : #endif
13170 : use pm_kind, only: SKC => SK1
13171 : character(*,SKC) , intent(out) :: rand(:)
13172 : character(*,SKC) , intent(in) :: lb, ub
13173 : type(splitmix64_type) , intent(inout) :: rng
13174 : end subroutine
13175 : #endif
13176 :
13177 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13178 :
13179 : #if IK5_ENABLED
13180 : PURE module subroutine setUnifRandRNGSLU_D1_IK5(rng, rand, lb, ub)
13181 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13182 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_IK5
13183 : #endif
13184 : use pm_kind, only: IKC => IK5
13185 : integer(IKC) , intent(out) :: rand(:)
13186 : integer(IKC) , intent(in) :: lb, ub
13187 : type(splitmix64_type) , intent(inout) :: rng
13188 : end subroutine
13189 : #endif
13190 :
13191 : #if IK4_ENABLED
13192 : PURE module subroutine setUnifRandRNGSLU_D1_IK4(rng, rand, lb, ub)
13193 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13194 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_IK4
13195 : #endif
13196 : use pm_kind, only: IKC => IK4
13197 : integer(IKC) , intent(out) :: rand(:)
13198 : integer(IKC) , intent(in) :: lb, ub
13199 : type(splitmix64_type) , intent(inout) :: rng
13200 : end subroutine
13201 : #endif
13202 :
13203 : #if IK3_ENABLED
13204 : PURE module subroutine setUnifRandRNGSLU_D1_IK3(rng, rand, lb, ub)
13205 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13206 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_IK3
13207 : #endif
13208 : use pm_kind, only: IKC => IK3
13209 : integer(IKC) , intent(out) :: rand(:)
13210 : integer(IKC) , intent(in) :: lb, ub
13211 : type(splitmix64_type) , intent(inout) :: rng
13212 : end subroutine
13213 : #endif
13214 :
13215 : #if IK2_ENABLED
13216 : PURE module subroutine setUnifRandRNGSLU_D1_IK2(rng, rand, lb, ub)
13217 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13218 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_IK2
13219 : #endif
13220 : use pm_kind, only: IKC => IK2
13221 : integer(IKC) , intent(out) :: rand(:)
13222 : integer(IKC) , intent(in) :: lb, ub
13223 : type(splitmix64_type) , intent(inout) :: rng
13224 : end subroutine
13225 : #endif
13226 :
13227 : #if IK1_ENABLED
13228 : PURE module subroutine setUnifRandRNGSLU_D1_IK1(rng, rand, lb, ub)
13229 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13230 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_IK1
13231 : #endif
13232 : use pm_kind, only: IKC => IK1
13233 : integer(IKC) , intent(out) :: rand(:)
13234 : integer(IKC) , intent(in) :: lb, ub
13235 : type(splitmix64_type) , intent(inout) :: rng
13236 : end subroutine
13237 : #endif
13238 :
13239 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13240 :
13241 : #if LK5_ENABLED
13242 : PURE module subroutine setUnifRandRNGSLU_D1_LK5(rng, rand, lb, ub)
13243 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13244 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_LK5
13245 : #endif
13246 : use pm_kind, only: LKC => LK5
13247 : logical(LKC) , intent(out) :: rand(:)
13248 : logical(LKC) , intent(in) :: lb, ub
13249 : type(splitmix64_type) , intent(inout) :: rng
13250 : end subroutine
13251 : #endif
13252 :
13253 : #if LK4_ENABLED
13254 : PURE module subroutine setUnifRandRNGSLU_D1_LK4(rng, rand, lb, ub)
13255 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13256 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_LK4
13257 : #endif
13258 : use pm_kind, only: LKC => LK4
13259 : logical(LKC) , intent(out) :: rand(:)
13260 : logical(LKC) , intent(in) :: lb, ub
13261 : type(splitmix64_type) , intent(inout) :: rng
13262 : end subroutine
13263 : #endif
13264 :
13265 : #if LK3_ENABLED
13266 : PURE module subroutine setUnifRandRNGSLU_D1_LK3(rng, rand, lb, ub)
13267 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13268 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_LK3
13269 : #endif
13270 : use pm_kind, only: LKC => LK3
13271 : logical(LKC) , intent(out) :: rand(:)
13272 : logical(LKC) , intent(in) :: lb, ub
13273 : type(splitmix64_type) , intent(inout) :: rng
13274 : end subroutine
13275 : #endif
13276 :
13277 : #if LK2_ENABLED
13278 : PURE module subroutine setUnifRandRNGSLU_D1_LK2(rng, rand, lb, ub)
13279 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13280 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_LK2
13281 : #endif
13282 : use pm_kind, only: LKC => LK2
13283 : logical(LKC) , intent(out) :: rand(:)
13284 : logical(LKC) , intent(in) :: lb, ub
13285 : type(splitmix64_type) , intent(inout) :: rng
13286 : end subroutine
13287 : #endif
13288 :
13289 : #if LK1_ENABLED
13290 : PURE module subroutine setUnifRandRNGSLU_D1_LK1(rng, rand, lb, ub)
13291 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13292 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_LK1
13293 : #endif
13294 : use pm_kind, only: LKC => LK1
13295 : logical(LKC) , intent(out) :: rand(:)
13296 : logical(LKC) , intent(in) :: lb, ub
13297 : type(splitmix64_type) , intent(inout) :: rng
13298 : end subroutine
13299 : #endif
13300 :
13301 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13302 :
13303 : #if CK5_ENABLED
13304 : PURE module subroutine setUnifRandRNGSLU_D1_CK5(rng, rand, lb, ub)
13305 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13306 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_CK5
13307 : #endif
13308 : use pm_kind, only: CKC => CK5
13309 : complex(CKC) , intent(out) :: rand(:)
13310 : complex(CKC) , intent(in) :: lb, ub
13311 : type(splitmix64_type) , intent(inout) :: rng
13312 : end subroutine
13313 : #endif
13314 :
13315 : #if CK4_ENABLED
13316 : PURE module subroutine setUnifRandRNGSLU_D1_CK4(rng, rand, lb, ub)
13317 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13318 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_CK4
13319 : #endif
13320 : use pm_kind, only: CKC => CK4
13321 : complex(CKC) , intent(out) :: rand(:)
13322 : complex(CKC) , intent(in) :: lb, ub
13323 : type(splitmix64_type) , intent(inout) :: rng
13324 : end subroutine
13325 : #endif
13326 :
13327 : #if CK3_ENABLED
13328 : PURE module subroutine setUnifRandRNGSLU_D1_CK3(rng, rand, lb, ub)
13329 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13330 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_CK3
13331 : #endif
13332 : use pm_kind, only: CKC => CK3
13333 : complex(CKC) , intent(out) :: rand(:)
13334 : complex(CKC) , intent(in) :: lb, ub
13335 : type(splitmix64_type) , intent(inout) :: rng
13336 : end subroutine
13337 : #endif
13338 :
13339 : #if CK2_ENABLED
13340 : PURE module subroutine setUnifRandRNGSLU_D1_CK2(rng, rand, lb, ub)
13341 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13342 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_CK2
13343 : #endif
13344 : use pm_kind, only: CKC => CK2
13345 : complex(CKC) , intent(out) :: rand(:)
13346 : complex(CKC) , intent(in) :: lb, ub
13347 : type(splitmix64_type) , intent(inout) :: rng
13348 : end subroutine
13349 : #endif
13350 :
13351 : #if CK1_ENABLED
13352 : PURE module subroutine setUnifRandRNGSLU_D1_CK1(rng, rand, lb, ub)
13353 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13354 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_CK1
13355 : #endif
13356 : use pm_kind, only: CKC => CK1
13357 : complex(CKC) , intent(out) :: rand(:)
13358 : complex(CKC) , intent(in) :: lb, ub
13359 : type(splitmix64_type) , intent(inout) :: rng
13360 : end subroutine
13361 : #endif
13362 :
13363 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13364 :
13365 : #if RK5_ENABLED
13366 : PURE module subroutine setUnifRandRNGSLU_D1_RK5(rng, rand, lb, ub)
13367 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13368 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_RK5
13369 : #endif
13370 : use pm_kind, only: RKC => RK5
13371 : real(RKC) , intent(out) :: rand(:)
13372 : real(RKC) , intent(in) :: lb, ub
13373 : type(splitmix64_type) , intent(inout) :: rng
13374 : end subroutine
13375 : #endif
13376 :
13377 : #if RK4_ENABLED
13378 : PURE module subroutine setUnifRandRNGSLU_D1_RK4(rng, rand, lb, ub)
13379 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13380 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_RK4
13381 : #endif
13382 : use pm_kind, only: RKC => RK4
13383 : real(RKC) , intent(out) :: rand(:)
13384 : real(RKC) , intent(in) :: lb, ub
13385 : type(splitmix64_type) , intent(inout) :: rng
13386 : end subroutine
13387 : #endif
13388 :
13389 : #if RK3_ENABLED
13390 : PURE module subroutine setUnifRandRNGSLU_D1_RK3(rng, rand, lb, ub)
13391 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13392 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_RK3
13393 : #endif
13394 : use pm_kind, only: RKC => RK3
13395 : real(RKC) , intent(out) :: rand(:)
13396 : real(RKC) , intent(in) :: lb, ub
13397 : type(splitmix64_type) , intent(inout) :: rng
13398 : end subroutine
13399 : #endif
13400 :
13401 : #if RK2_ENABLED
13402 : PURE module subroutine setUnifRandRNGSLU_D1_RK2(rng, rand, lb, ub)
13403 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13404 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_RK2
13405 : #endif
13406 : use pm_kind, only: RKC => RK2
13407 : real(RKC) , intent(out) :: rand(:)
13408 : real(RKC) , intent(in) :: lb, ub
13409 : type(splitmix64_type) , intent(inout) :: rng
13410 : end subroutine
13411 : #endif
13412 :
13413 : #if RK1_ENABLED
13414 : PURE module subroutine setUnifRandRNGSLU_D1_RK1(rng, rand, lb, ub)
13415 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13416 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D1_RK1
13417 : #endif
13418 : use pm_kind, only: RKC => RK1
13419 : real(RKC) , intent(out) :: rand(:)
13420 : real(RKC) , intent(in) :: lb, ub
13421 : type(splitmix64_type) , intent(inout) :: rng
13422 : end subroutine
13423 : #endif
13424 :
13425 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13426 :
13427 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13428 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13429 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13430 :
13431 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13432 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13433 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13434 :
13435 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13436 :
13437 : #if SK5_ENABLED
13438 : PURE module subroutine setUnifRandRNGSDD_D2_SK5(rng, rand)
13439 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13440 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_SK5
13441 : #endif
13442 : use pm_kind, only: SKC => SK5
13443 : character(*,SKC) , intent(out) :: rand(:,:)
13444 : type(splitmix64_type) , intent(inout) :: rng
13445 : end subroutine
13446 : #endif
13447 :
13448 : #if SK4_ENABLED
13449 : PURE module subroutine setUnifRandRNGSDD_D2_SK4(rng, rand)
13450 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13451 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_SK4
13452 : #endif
13453 : use pm_kind, only: SKC => SK4
13454 : character(*,SKC) , intent(out) :: rand(:,:)
13455 : type(splitmix64_type) , intent(inout) :: rng
13456 : end subroutine
13457 : #endif
13458 :
13459 : #if SK3_ENABLED
13460 : PURE module subroutine setUnifRandRNGSDD_D2_SK3(rng, rand)
13461 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13462 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_SK3
13463 : #endif
13464 : use pm_kind, only: SKC => SK3
13465 : character(*,SKC) , intent(out) :: rand(:,:)
13466 : type(splitmix64_type) , intent(inout) :: rng
13467 : end subroutine
13468 : #endif
13469 :
13470 : #if SK2_ENABLED
13471 : PURE module subroutine setUnifRandRNGSDD_D2_SK2(rng, rand)
13472 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13473 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_SK2
13474 : #endif
13475 : use pm_kind, only: SKC => SK2
13476 : character(*,SKC) , intent(out) :: rand(:,:)
13477 : type(splitmix64_type) , intent(inout) :: rng
13478 : end subroutine
13479 : #endif
13480 :
13481 : #if SK1_ENABLED
13482 : PURE module subroutine setUnifRandRNGSDD_D2_SK1(rng, rand)
13483 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13484 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_SK1
13485 : #endif
13486 : use pm_kind, only: SKC => SK1
13487 : character(*,SKC) , intent(out) :: rand(:,:)
13488 : type(splitmix64_type) , intent(inout) :: rng
13489 : end subroutine
13490 : #endif
13491 :
13492 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13493 :
13494 : #if IK5_ENABLED
13495 : PURE module subroutine setUnifRandRNGSDD_D2_IK5(rng, rand)
13496 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13497 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_IK5
13498 : #endif
13499 : use pm_kind, only: IKC => IK5
13500 : integer(IKC) , intent(out) :: rand(:,:)
13501 : type(splitmix64_type) , intent(inout) :: rng
13502 : end subroutine
13503 : #endif
13504 :
13505 : #if IK4_ENABLED
13506 : PURE module subroutine setUnifRandRNGSDD_D2_IK4(rng, rand)
13507 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13508 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_IK4
13509 : #endif
13510 : use pm_kind, only: IKC => IK4
13511 : integer(IKC) , intent(out) :: rand(:,:)
13512 : type(splitmix64_type) , intent(inout) :: rng
13513 : end subroutine
13514 : #endif
13515 :
13516 : #if IK3_ENABLED
13517 : PURE module subroutine setUnifRandRNGSDD_D2_IK3(rng, rand)
13518 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13519 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_IK3
13520 : #endif
13521 : use pm_kind, only: IKC => IK3
13522 : integer(IKC) , intent(out) :: rand(:,:)
13523 : type(splitmix64_type) , intent(inout) :: rng
13524 : end subroutine
13525 : #endif
13526 :
13527 : #if IK2_ENABLED
13528 : PURE module subroutine setUnifRandRNGSDD_D2_IK2(rng, rand)
13529 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13530 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_IK2
13531 : #endif
13532 : use pm_kind, only: IKC => IK2
13533 : integer(IKC) , intent(out) :: rand(:,:)
13534 : type(splitmix64_type) , intent(inout) :: rng
13535 : end subroutine
13536 : #endif
13537 :
13538 : #if IK1_ENABLED
13539 : PURE module subroutine setUnifRandRNGSDD_D2_IK1(rng, rand)
13540 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13541 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_IK1
13542 : #endif
13543 : use pm_kind, only: IKC => IK1
13544 : integer(IKC) , intent(out) :: rand(:,:)
13545 : type(splitmix64_type) , intent(inout) :: rng
13546 : end subroutine
13547 : #endif
13548 :
13549 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13550 :
13551 : #if LK5_ENABLED
13552 : PURE module subroutine setUnifRandRNGSDD_D2_LK5(rng, rand)
13553 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13554 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_LK5
13555 : #endif
13556 : use pm_kind, only: LKC => LK5
13557 : logical(LKC) , intent(out) :: rand(:,:)
13558 : type(splitmix64_type) , intent(inout) :: rng
13559 : end subroutine
13560 : #endif
13561 :
13562 : #if LK4_ENABLED
13563 : PURE module subroutine setUnifRandRNGSDD_D2_LK4(rng, rand)
13564 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13565 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_LK4
13566 : #endif
13567 : use pm_kind, only: LKC => LK4
13568 : logical(LKC) , intent(out) :: rand(:,:)
13569 : type(splitmix64_type) , intent(inout) :: rng
13570 : end subroutine
13571 : #endif
13572 :
13573 : #if LK3_ENABLED
13574 : PURE module subroutine setUnifRandRNGSDD_D2_LK3(rng, rand)
13575 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13576 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_LK3
13577 : #endif
13578 : use pm_kind, only: LKC => LK3
13579 : logical(LKC) , intent(out) :: rand(:,:)
13580 : type(splitmix64_type) , intent(inout) :: rng
13581 : end subroutine
13582 : #endif
13583 :
13584 : #if LK2_ENABLED
13585 : PURE module subroutine setUnifRandRNGSDD_D2_LK2(rng, rand)
13586 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13587 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_LK2
13588 : #endif
13589 : use pm_kind, only: LKC => LK2
13590 : logical(LKC) , intent(out) :: rand(:,:)
13591 : type(splitmix64_type) , intent(inout) :: rng
13592 : end subroutine
13593 : #endif
13594 :
13595 : #if LK1_ENABLED
13596 : PURE module subroutine setUnifRandRNGSDD_D2_LK1(rng, rand)
13597 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13598 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_LK1
13599 : #endif
13600 : use pm_kind, only: LKC => LK1
13601 : logical(LKC) , intent(out) :: rand(:,:)
13602 : type(splitmix64_type) , intent(inout) :: rng
13603 : end subroutine
13604 : #endif
13605 :
13606 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13607 :
13608 : #if CK5_ENABLED
13609 : PURE module subroutine setUnifRandRNGSDD_D2_CK5(rng, rand)
13610 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13611 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_CK5
13612 : #endif
13613 : use pm_kind, only: CKC => CK5
13614 : complex(CKC) , intent(out) :: rand(:,:)
13615 : type(splitmix64_type) , intent(inout) :: rng
13616 : end subroutine
13617 : #endif
13618 :
13619 : #if CK4_ENABLED
13620 : PURE module subroutine setUnifRandRNGSDD_D2_CK4(rng, rand)
13621 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13622 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_CK4
13623 : #endif
13624 : use pm_kind, only: CKC => CK4
13625 : complex(CKC) , intent(out) :: rand(:,:)
13626 : type(splitmix64_type) , intent(inout) :: rng
13627 : end subroutine
13628 : #endif
13629 :
13630 : #if CK3_ENABLED
13631 : PURE module subroutine setUnifRandRNGSDD_D2_CK3(rng, rand)
13632 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13633 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_CK3
13634 : #endif
13635 : use pm_kind, only: CKC => CK3
13636 : complex(CKC) , intent(out) :: rand(:,:)
13637 : type(splitmix64_type) , intent(inout) :: rng
13638 : end subroutine
13639 : #endif
13640 :
13641 : #if CK2_ENABLED
13642 : PURE module subroutine setUnifRandRNGSDD_D2_CK2(rng, rand)
13643 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13644 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_CK2
13645 : #endif
13646 : use pm_kind, only: CKC => CK2
13647 : complex(CKC) , intent(out) :: rand(:,:)
13648 : type(splitmix64_type) , intent(inout) :: rng
13649 : end subroutine
13650 : #endif
13651 :
13652 : #if CK1_ENABLED
13653 : PURE module subroutine setUnifRandRNGSDD_D2_CK1(rng, rand)
13654 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13655 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_CK1
13656 : #endif
13657 : use pm_kind, only: CKC => CK1
13658 : complex(CKC) , intent(out) :: rand(:,:)
13659 : type(splitmix64_type) , intent(inout) :: rng
13660 : end subroutine
13661 : #endif
13662 :
13663 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13664 :
13665 : #if RK5_ENABLED
13666 : PURE module subroutine setUnifRandRNGSDD_D2_RK5(rng, rand)
13667 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13668 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_RK5
13669 : #endif
13670 : use pm_kind, only: RKC => RK5
13671 : real(RKC) , intent(out) :: rand(:,:)
13672 : type(splitmix64_type) , intent(inout) :: rng
13673 : end subroutine
13674 : #endif
13675 :
13676 : #if RK4_ENABLED
13677 : PURE module subroutine setUnifRandRNGSDD_D2_RK4(rng, rand)
13678 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13679 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_RK4
13680 : #endif
13681 : use pm_kind, only: RKC => RK4
13682 : real(RKC) , intent(out) :: rand(:,:)
13683 : type(splitmix64_type) , intent(inout) :: rng
13684 : end subroutine
13685 : #endif
13686 :
13687 : #if RK3_ENABLED
13688 : PURE module subroutine setUnifRandRNGSDD_D2_RK3(rng, rand)
13689 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13690 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_RK3
13691 : #endif
13692 : use pm_kind, only: RKC => RK3
13693 : real(RKC) , intent(out) :: rand(:,:)
13694 : type(splitmix64_type) , intent(inout) :: rng
13695 : end subroutine
13696 : #endif
13697 :
13698 : #if RK2_ENABLED
13699 : PURE module subroutine setUnifRandRNGSDD_D2_RK2(rng, rand)
13700 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13701 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_RK2
13702 : #endif
13703 : use pm_kind, only: RKC => RK2
13704 : real(RKC) , intent(out) :: rand(:,:)
13705 : type(splitmix64_type) , intent(inout) :: rng
13706 : end subroutine
13707 : #endif
13708 :
13709 : #if RK1_ENABLED
13710 : PURE module subroutine setUnifRandRNGSDD_D2_RK1(rng, rand)
13711 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13712 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D2_RK1
13713 : #endif
13714 : use pm_kind, only: RKC => RK1
13715 : real(RKC) , intent(out) :: rand(:,:)
13716 : type(splitmix64_type) , intent(inout) :: rng
13717 : end subroutine
13718 : #endif
13719 :
13720 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13721 :
13722 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13723 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13724 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13725 :
13726 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13727 :
13728 : #if SK5_ENABLED
13729 : PURE module subroutine setUnifRandRNGSLU_D2_SK5(rng, rand, lb, ub)
13730 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13731 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_SK5
13732 : #endif
13733 : use pm_kind, only: SKC => SK5
13734 : character(*,SKC) , intent(out) :: rand(:,:)
13735 : character(*,SKC) , intent(in) :: lb, ub
13736 : type(splitmix64_type) , intent(inout) :: rng
13737 : end subroutine
13738 : #endif
13739 :
13740 : #if SK4_ENABLED
13741 : PURE module subroutine setUnifRandRNGSLU_D2_SK4(rng, rand, lb, ub)
13742 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13743 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_SK4
13744 : #endif
13745 : use pm_kind, only: SKC => SK4
13746 : character(*,SKC) , intent(out) :: rand(:,:)
13747 : character(*,SKC) , intent(in) :: lb, ub
13748 : type(splitmix64_type) , intent(inout) :: rng
13749 : end subroutine
13750 : #endif
13751 :
13752 : #if SK3_ENABLED
13753 : PURE module subroutine setUnifRandRNGSLU_D2_SK3(rng, rand, lb, ub)
13754 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13755 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_SK3
13756 : #endif
13757 : use pm_kind, only: SKC => SK3
13758 : character(*,SKC) , intent(out) :: rand(:,:)
13759 : character(*,SKC) , intent(in) :: lb, ub
13760 : type(splitmix64_type) , intent(inout) :: rng
13761 : end subroutine
13762 : #endif
13763 :
13764 : #if SK2_ENABLED
13765 : PURE module subroutine setUnifRandRNGSLU_D2_SK2(rng, rand, lb, ub)
13766 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13767 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_SK2
13768 : #endif
13769 : use pm_kind, only: SKC => SK2
13770 : character(*,SKC) , intent(out) :: rand(:,:)
13771 : character(*,SKC) , intent(in) :: lb, ub
13772 : type(splitmix64_type) , intent(inout) :: rng
13773 : end subroutine
13774 : #endif
13775 :
13776 : #if SK1_ENABLED
13777 : PURE module subroutine setUnifRandRNGSLU_D2_SK1(rng, rand, lb, ub)
13778 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13779 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_SK1
13780 : #endif
13781 : use pm_kind, only: SKC => SK1
13782 : character(*,SKC) , intent(out) :: rand(:,:)
13783 : character(*,SKC) , intent(in) :: lb, ub
13784 : type(splitmix64_type) , intent(inout) :: rng
13785 : end subroutine
13786 : #endif
13787 :
13788 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13789 :
13790 : #if IK5_ENABLED
13791 : PURE module subroutine setUnifRandRNGSLU_D2_IK5(rng, rand, lb, ub)
13792 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13793 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_IK5
13794 : #endif
13795 : use pm_kind, only: IKC => IK5
13796 : integer(IKC) , intent(out) :: rand(:,:)
13797 : integer(IKC) , intent(in) :: lb, ub
13798 : type(splitmix64_type) , intent(inout) :: rng
13799 : end subroutine
13800 : #endif
13801 :
13802 : #if IK4_ENABLED
13803 : PURE module subroutine setUnifRandRNGSLU_D2_IK4(rng, rand, lb, ub)
13804 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13805 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_IK4
13806 : #endif
13807 : use pm_kind, only: IKC => IK4
13808 : integer(IKC) , intent(out) :: rand(:,:)
13809 : integer(IKC) , intent(in) :: lb, ub
13810 : type(splitmix64_type) , intent(inout) :: rng
13811 : end subroutine
13812 : #endif
13813 :
13814 : #if IK3_ENABLED
13815 : PURE module subroutine setUnifRandRNGSLU_D2_IK3(rng, rand, lb, ub)
13816 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13817 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_IK3
13818 : #endif
13819 : use pm_kind, only: IKC => IK3
13820 : integer(IKC) , intent(out) :: rand(:,:)
13821 : integer(IKC) , intent(in) :: lb, ub
13822 : type(splitmix64_type) , intent(inout) :: rng
13823 : end subroutine
13824 : #endif
13825 :
13826 : #if IK2_ENABLED
13827 : PURE module subroutine setUnifRandRNGSLU_D2_IK2(rng, rand, lb, ub)
13828 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13829 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_IK2
13830 : #endif
13831 : use pm_kind, only: IKC => IK2
13832 : integer(IKC) , intent(out) :: rand(:,:)
13833 : integer(IKC) , intent(in) :: lb, ub
13834 : type(splitmix64_type) , intent(inout) :: rng
13835 : end subroutine
13836 : #endif
13837 :
13838 : #if IK1_ENABLED
13839 : PURE module subroutine setUnifRandRNGSLU_D2_IK1(rng, rand, lb, ub)
13840 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13841 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_IK1
13842 : #endif
13843 : use pm_kind, only: IKC => IK1
13844 : integer(IKC) , intent(out) :: rand(:,:)
13845 : integer(IKC) , intent(in) :: lb, ub
13846 : type(splitmix64_type) , intent(inout) :: rng
13847 : end subroutine
13848 : #endif
13849 :
13850 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13851 :
13852 : #if LK5_ENABLED
13853 : PURE module subroutine setUnifRandRNGSLU_D2_LK5(rng, rand, lb, ub)
13854 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13855 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_LK5
13856 : #endif
13857 : use pm_kind, only: LKC => LK5
13858 : logical(LKC) , intent(out) :: rand(:,:)
13859 : logical(LKC) , intent(in) :: lb, ub
13860 : type(splitmix64_type) , intent(inout) :: rng
13861 : end subroutine
13862 : #endif
13863 :
13864 : #if LK4_ENABLED
13865 : PURE module subroutine setUnifRandRNGSLU_D2_LK4(rng, rand, lb, ub)
13866 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13867 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_LK4
13868 : #endif
13869 : use pm_kind, only: LKC => LK4
13870 : logical(LKC) , intent(out) :: rand(:,:)
13871 : logical(LKC) , intent(in) :: lb, ub
13872 : type(splitmix64_type) , intent(inout) :: rng
13873 : end subroutine
13874 : #endif
13875 :
13876 : #if LK3_ENABLED
13877 : PURE module subroutine setUnifRandRNGSLU_D2_LK3(rng, rand, lb, ub)
13878 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13879 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_LK3
13880 : #endif
13881 : use pm_kind, only: LKC => LK3
13882 : logical(LKC) , intent(out) :: rand(:,:)
13883 : logical(LKC) , intent(in) :: lb, ub
13884 : type(splitmix64_type) , intent(inout) :: rng
13885 : end subroutine
13886 : #endif
13887 :
13888 : #if LK2_ENABLED
13889 : PURE module subroutine setUnifRandRNGSLU_D2_LK2(rng, rand, lb, ub)
13890 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13891 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_LK2
13892 : #endif
13893 : use pm_kind, only: LKC => LK2
13894 : logical(LKC) , intent(out) :: rand(:,:)
13895 : logical(LKC) , intent(in) :: lb, ub
13896 : type(splitmix64_type) , intent(inout) :: rng
13897 : end subroutine
13898 : #endif
13899 :
13900 : #if LK1_ENABLED
13901 : PURE module subroutine setUnifRandRNGSLU_D2_LK1(rng, rand, lb, ub)
13902 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13903 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_LK1
13904 : #endif
13905 : use pm_kind, only: LKC => LK1
13906 : logical(LKC) , intent(out) :: rand(:,:)
13907 : logical(LKC) , intent(in) :: lb, ub
13908 : type(splitmix64_type) , intent(inout) :: rng
13909 : end subroutine
13910 : #endif
13911 :
13912 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13913 :
13914 : #if CK5_ENABLED
13915 : PURE module subroutine setUnifRandRNGSLU_D2_CK5(rng, rand, lb, ub)
13916 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13917 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_CK5
13918 : #endif
13919 : use pm_kind, only: CKC => CK5
13920 : complex(CKC) , intent(out) :: rand(:,:)
13921 : complex(CKC) , intent(in) :: lb, ub
13922 : type(splitmix64_type) , intent(inout) :: rng
13923 : end subroutine
13924 : #endif
13925 :
13926 : #if CK4_ENABLED
13927 : PURE module subroutine setUnifRandRNGSLU_D2_CK4(rng, rand, lb, ub)
13928 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13929 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_CK4
13930 : #endif
13931 : use pm_kind, only: CKC => CK4
13932 : complex(CKC) , intent(out) :: rand(:,:)
13933 : complex(CKC) , intent(in) :: lb, ub
13934 : type(splitmix64_type) , intent(inout) :: rng
13935 : end subroutine
13936 : #endif
13937 :
13938 : #if CK3_ENABLED
13939 : PURE module subroutine setUnifRandRNGSLU_D2_CK3(rng, rand, lb, ub)
13940 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13941 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_CK3
13942 : #endif
13943 : use pm_kind, only: CKC => CK3
13944 : complex(CKC) , intent(out) :: rand(:,:)
13945 : complex(CKC) , intent(in) :: lb, ub
13946 : type(splitmix64_type) , intent(inout) :: rng
13947 : end subroutine
13948 : #endif
13949 :
13950 : #if CK2_ENABLED
13951 : PURE module subroutine setUnifRandRNGSLU_D2_CK2(rng, rand, lb, ub)
13952 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13953 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_CK2
13954 : #endif
13955 : use pm_kind, only: CKC => CK2
13956 : complex(CKC) , intent(out) :: rand(:,:)
13957 : complex(CKC) , intent(in) :: lb, ub
13958 : type(splitmix64_type) , intent(inout) :: rng
13959 : end subroutine
13960 : #endif
13961 :
13962 : #if CK1_ENABLED
13963 : PURE module subroutine setUnifRandRNGSLU_D2_CK1(rng, rand, lb, ub)
13964 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13965 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_CK1
13966 : #endif
13967 : use pm_kind, only: CKC => CK1
13968 : complex(CKC) , intent(out) :: rand(:,:)
13969 : complex(CKC) , intent(in) :: lb, ub
13970 : type(splitmix64_type) , intent(inout) :: rng
13971 : end subroutine
13972 : #endif
13973 :
13974 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
13975 :
13976 : #if RK5_ENABLED
13977 : PURE module subroutine setUnifRandRNGSLU_D2_RK5(rng, rand, lb, ub)
13978 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13979 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_RK5
13980 : #endif
13981 : use pm_kind, only: RKC => RK5
13982 : real(RKC) , intent(out) :: rand(:,:)
13983 : real(RKC) , intent(in) :: lb, ub
13984 : type(splitmix64_type) , intent(inout) :: rng
13985 : end subroutine
13986 : #endif
13987 :
13988 : #if RK4_ENABLED
13989 : PURE module subroutine setUnifRandRNGSLU_D2_RK4(rng, rand, lb, ub)
13990 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
13991 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_RK4
13992 : #endif
13993 : use pm_kind, only: RKC => RK4
13994 : real(RKC) , intent(out) :: rand(:,:)
13995 : real(RKC) , intent(in) :: lb, ub
13996 : type(splitmix64_type) , intent(inout) :: rng
13997 : end subroutine
13998 : #endif
13999 :
14000 : #if RK3_ENABLED
14001 : PURE module subroutine setUnifRandRNGSLU_D2_RK3(rng, rand, lb, ub)
14002 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14003 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_RK3
14004 : #endif
14005 : use pm_kind, only: RKC => RK3
14006 : real(RKC) , intent(out) :: rand(:,:)
14007 : real(RKC) , intent(in) :: lb, ub
14008 : type(splitmix64_type) , intent(inout) :: rng
14009 : end subroutine
14010 : #endif
14011 :
14012 : #if RK2_ENABLED
14013 : PURE module subroutine setUnifRandRNGSLU_D2_RK2(rng, rand, lb, ub)
14014 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14015 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_RK2
14016 : #endif
14017 : use pm_kind, only: RKC => RK2
14018 : real(RKC) , intent(out) :: rand(:,:)
14019 : real(RKC) , intent(in) :: lb, ub
14020 : type(splitmix64_type) , intent(inout) :: rng
14021 : end subroutine
14022 : #endif
14023 :
14024 : #if RK1_ENABLED
14025 : PURE module subroutine setUnifRandRNGSLU_D2_RK1(rng, rand, lb, ub)
14026 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14027 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D2_RK1
14028 : #endif
14029 : use pm_kind, only: RKC => RK1
14030 : real(RKC) , intent(out) :: rand(:,:)
14031 : real(RKC) , intent(in) :: lb, ub
14032 : type(splitmix64_type) , intent(inout) :: rng
14033 : end subroutine
14034 : #endif
14035 :
14036 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14037 :
14038 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14039 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14040 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14041 :
14042 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14043 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14044 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14045 :
14046 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14047 :
14048 : #if SK5_ENABLED
14049 : PURE module subroutine setUnifRandRNGSDD_D3_SK5(rng, rand)
14050 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14051 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_SK5
14052 : #endif
14053 : use pm_kind, only: SKC => SK5
14054 : character(*,SKC) , intent(out) :: rand(:,:,:)
14055 : type(splitmix64_type) , intent(inout) :: rng
14056 : end subroutine
14057 : #endif
14058 :
14059 : #if SK4_ENABLED
14060 : PURE module subroutine setUnifRandRNGSDD_D3_SK4(rng, rand)
14061 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14062 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_SK4
14063 : #endif
14064 : use pm_kind, only: SKC => SK4
14065 : character(*,SKC) , intent(out) :: rand(:,:,:)
14066 : type(splitmix64_type) , intent(inout) :: rng
14067 : end subroutine
14068 : #endif
14069 :
14070 : #if SK3_ENABLED
14071 : PURE module subroutine setUnifRandRNGSDD_D3_SK3(rng, rand)
14072 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14073 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_SK3
14074 : #endif
14075 : use pm_kind, only: SKC => SK3
14076 : character(*,SKC) , intent(out) :: rand(:,:,:)
14077 : type(splitmix64_type) , intent(inout) :: rng
14078 : end subroutine
14079 : #endif
14080 :
14081 : #if SK2_ENABLED
14082 : PURE module subroutine setUnifRandRNGSDD_D3_SK2(rng, rand)
14083 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14084 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_SK2
14085 : #endif
14086 : use pm_kind, only: SKC => SK2
14087 : character(*,SKC) , intent(out) :: rand(:,:,:)
14088 : type(splitmix64_type) , intent(inout) :: rng
14089 : end subroutine
14090 : #endif
14091 :
14092 : #if SK1_ENABLED
14093 : PURE module subroutine setUnifRandRNGSDD_D3_SK1(rng, rand)
14094 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14095 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_SK1
14096 : #endif
14097 : use pm_kind, only: SKC => SK1
14098 : character(*,SKC) , intent(out) :: rand(:,:,:)
14099 : type(splitmix64_type) , intent(inout) :: rng
14100 : end subroutine
14101 : #endif
14102 :
14103 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14104 :
14105 : #if IK5_ENABLED
14106 : PURE module subroutine setUnifRandRNGSDD_D3_IK5(rng, rand)
14107 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14108 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_IK5
14109 : #endif
14110 : use pm_kind, only: IKC => IK5
14111 : integer(IKC) , intent(out) :: rand(:,:,:)
14112 : type(splitmix64_type) , intent(inout) :: rng
14113 : end subroutine
14114 : #endif
14115 :
14116 : #if IK4_ENABLED
14117 : PURE module subroutine setUnifRandRNGSDD_D3_IK4(rng, rand)
14118 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14119 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_IK4
14120 : #endif
14121 : use pm_kind, only: IKC => IK4
14122 : integer(IKC) , intent(out) :: rand(:,:,:)
14123 : type(splitmix64_type) , intent(inout) :: rng
14124 : end subroutine
14125 : #endif
14126 :
14127 : #if IK3_ENABLED
14128 : PURE module subroutine setUnifRandRNGSDD_D3_IK3(rng, rand)
14129 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14130 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_IK3
14131 : #endif
14132 : use pm_kind, only: IKC => IK3
14133 : integer(IKC) , intent(out) :: rand(:,:,:)
14134 : type(splitmix64_type) , intent(inout) :: rng
14135 : end subroutine
14136 : #endif
14137 :
14138 : #if IK2_ENABLED
14139 : PURE module subroutine setUnifRandRNGSDD_D3_IK2(rng, rand)
14140 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14141 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_IK2
14142 : #endif
14143 : use pm_kind, only: IKC => IK2
14144 : integer(IKC) , intent(out) :: rand(:,:,:)
14145 : type(splitmix64_type) , intent(inout) :: rng
14146 : end subroutine
14147 : #endif
14148 :
14149 : #if IK1_ENABLED
14150 : PURE module subroutine setUnifRandRNGSDD_D3_IK1(rng, rand)
14151 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14152 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_IK1
14153 : #endif
14154 : use pm_kind, only: IKC => IK1
14155 : integer(IKC) , intent(out) :: rand(:,:,:)
14156 : type(splitmix64_type) , intent(inout) :: rng
14157 : end subroutine
14158 : #endif
14159 :
14160 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14161 :
14162 : #if LK5_ENABLED
14163 : PURE module subroutine setUnifRandRNGSDD_D3_LK5(rng, rand)
14164 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14165 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_LK5
14166 : #endif
14167 : use pm_kind, only: LKC => LK5
14168 : logical(LKC) , intent(out) :: rand(:,:,:)
14169 : type(splitmix64_type) , intent(inout) :: rng
14170 : end subroutine
14171 : #endif
14172 :
14173 : #if LK4_ENABLED
14174 : PURE module subroutine setUnifRandRNGSDD_D3_LK4(rng, rand)
14175 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14176 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_LK4
14177 : #endif
14178 : use pm_kind, only: LKC => LK4
14179 : logical(LKC) , intent(out) :: rand(:,:,:)
14180 : type(splitmix64_type) , intent(inout) :: rng
14181 : end subroutine
14182 : #endif
14183 :
14184 : #if LK3_ENABLED
14185 : PURE module subroutine setUnifRandRNGSDD_D3_LK3(rng, rand)
14186 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14187 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_LK3
14188 : #endif
14189 : use pm_kind, only: LKC => LK3
14190 : logical(LKC) , intent(out) :: rand(:,:,:)
14191 : type(splitmix64_type) , intent(inout) :: rng
14192 : end subroutine
14193 : #endif
14194 :
14195 : #if LK2_ENABLED
14196 : PURE module subroutine setUnifRandRNGSDD_D3_LK2(rng, rand)
14197 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14198 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_LK2
14199 : #endif
14200 : use pm_kind, only: LKC => LK2
14201 : logical(LKC) , intent(out) :: rand(:,:,:)
14202 : type(splitmix64_type) , intent(inout) :: rng
14203 : end subroutine
14204 : #endif
14205 :
14206 : #if LK1_ENABLED
14207 : PURE module subroutine setUnifRandRNGSDD_D3_LK1(rng, rand)
14208 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14209 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_LK1
14210 : #endif
14211 : use pm_kind, only: LKC => LK1
14212 : logical(LKC) , intent(out) :: rand(:,:,:)
14213 : type(splitmix64_type) , intent(inout) :: rng
14214 : end subroutine
14215 : #endif
14216 :
14217 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14218 :
14219 : #if CK5_ENABLED
14220 : PURE module subroutine setUnifRandRNGSDD_D3_CK5(rng, rand)
14221 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14222 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_CK5
14223 : #endif
14224 : use pm_kind, only: CKC => CK5
14225 : complex(CKC) , intent(out) :: rand(:,:,:)
14226 : type(splitmix64_type) , intent(inout) :: rng
14227 : end subroutine
14228 : #endif
14229 :
14230 : #if CK4_ENABLED
14231 : PURE module subroutine setUnifRandRNGSDD_D3_CK4(rng, rand)
14232 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14233 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_CK4
14234 : #endif
14235 : use pm_kind, only: CKC => CK4
14236 : complex(CKC) , intent(out) :: rand(:,:,:)
14237 : type(splitmix64_type) , intent(inout) :: rng
14238 : end subroutine
14239 : #endif
14240 :
14241 : #if CK3_ENABLED
14242 : PURE module subroutine setUnifRandRNGSDD_D3_CK3(rng, rand)
14243 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14244 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_CK3
14245 : #endif
14246 : use pm_kind, only: CKC => CK3
14247 : complex(CKC) , intent(out) :: rand(:,:,:)
14248 : type(splitmix64_type) , intent(inout) :: rng
14249 : end subroutine
14250 : #endif
14251 :
14252 : #if CK2_ENABLED
14253 : PURE module subroutine setUnifRandRNGSDD_D3_CK2(rng, rand)
14254 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14255 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_CK2
14256 : #endif
14257 : use pm_kind, only: CKC => CK2
14258 : complex(CKC) , intent(out) :: rand(:,:,:)
14259 : type(splitmix64_type) , intent(inout) :: rng
14260 : end subroutine
14261 : #endif
14262 :
14263 : #if CK1_ENABLED
14264 : PURE module subroutine setUnifRandRNGSDD_D3_CK1(rng, rand)
14265 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14266 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_CK1
14267 : #endif
14268 : use pm_kind, only: CKC => CK1
14269 : complex(CKC) , intent(out) :: rand(:,:,:)
14270 : type(splitmix64_type) , intent(inout) :: rng
14271 : end subroutine
14272 : #endif
14273 :
14274 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14275 :
14276 : #if RK5_ENABLED
14277 : PURE module subroutine setUnifRandRNGSDD_D3_RK5(rng, rand)
14278 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14279 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_RK5
14280 : #endif
14281 : use pm_kind, only: RKC => RK5
14282 : real(RKC) , intent(out) :: rand(:,:,:)
14283 : type(splitmix64_type) , intent(inout) :: rng
14284 : end subroutine
14285 : #endif
14286 :
14287 : #if RK4_ENABLED
14288 : PURE module subroutine setUnifRandRNGSDD_D3_RK4(rng, rand)
14289 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14290 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_RK4
14291 : #endif
14292 : use pm_kind, only: RKC => RK4
14293 : real(RKC) , intent(out) :: rand(:,:,:)
14294 : type(splitmix64_type) , intent(inout) :: rng
14295 : end subroutine
14296 : #endif
14297 :
14298 : #if RK3_ENABLED
14299 : PURE module subroutine setUnifRandRNGSDD_D3_RK3(rng, rand)
14300 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14301 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_RK3
14302 : #endif
14303 : use pm_kind, only: RKC => RK3
14304 : real(RKC) , intent(out) :: rand(:,:,:)
14305 : type(splitmix64_type) , intent(inout) :: rng
14306 : end subroutine
14307 : #endif
14308 :
14309 : #if RK2_ENABLED
14310 : PURE module subroutine setUnifRandRNGSDD_D3_RK2(rng, rand)
14311 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14312 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_RK2
14313 : #endif
14314 : use pm_kind, only: RKC => RK2
14315 : real(RKC) , intent(out) :: rand(:,:,:)
14316 : type(splitmix64_type) , intent(inout) :: rng
14317 : end subroutine
14318 : #endif
14319 :
14320 : #if RK1_ENABLED
14321 : PURE module subroutine setUnifRandRNGSDD_D3_RK1(rng, rand)
14322 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14323 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSDD_D3_RK1
14324 : #endif
14325 : use pm_kind, only: RKC => RK1
14326 : real(RKC) , intent(out) :: rand(:,:,:)
14327 : type(splitmix64_type) , intent(inout) :: rng
14328 : end subroutine
14329 : #endif
14330 :
14331 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14332 :
14333 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14334 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14335 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14336 :
14337 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14338 :
14339 : #if SK5_ENABLED
14340 : PURE module subroutine setUnifRandRNGSLU_D3_SK5(rng, rand, lb, ub)
14341 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14342 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_SK5
14343 : #endif
14344 : use pm_kind, only: SKC => SK5
14345 : character(*,SKC) , intent(out) :: rand(:,:,:)
14346 : character(*,SKC) , intent(in) :: lb, ub
14347 : type(splitmix64_type) , intent(inout) :: rng
14348 : end subroutine
14349 : #endif
14350 :
14351 : #if SK4_ENABLED
14352 : PURE module subroutine setUnifRandRNGSLU_D3_SK4(rng, rand, lb, ub)
14353 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14354 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_SK4
14355 : #endif
14356 : use pm_kind, only: SKC => SK4
14357 : character(*,SKC) , intent(out) :: rand(:,:,:)
14358 : character(*,SKC) , intent(in) :: lb, ub
14359 : type(splitmix64_type) , intent(inout) :: rng
14360 : end subroutine
14361 : #endif
14362 :
14363 : #if SK3_ENABLED
14364 : PURE module subroutine setUnifRandRNGSLU_D3_SK3(rng, rand, lb, ub)
14365 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14366 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_SK3
14367 : #endif
14368 : use pm_kind, only: SKC => SK3
14369 : character(*,SKC) , intent(out) :: rand(:,:,:)
14370 : character(*,SKC) , intent(in) :: lb, ub
14371 : type(splitmix64_type) , intent(inout) :: rng
14372 : end subroutine
14373 : #endif
14374 :
14375 : #if SK2_ENABLED
14376 : PURE module subroutine setUnifRandRNGSLU_D3_SK2(rng, rand, lb, ub)
14377 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14378 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_SK2
14379 : #endif
14380 : use pm_kind, only: SKC => SK2
14381 : character(*,SKC) , intent(out) :: rand(:,:,:)
14382 : character(*,SKC) , intent(in) :: lb, ub
14383 : type(splitmix64_type) , intent(inout) :: rng
14384 : end subroutine
14385 : #endif
14386 :
14387 : #if SK1_ENABLED
14388 : PURE module subroutine setUnifRandRNGSLU_D3_SK1(rng, rand, lb, ub)
14389 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14390 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_SK1
14391 : #endif
14392 : use pm_kind, only: SKC => SK1
14393 : character(*,SKC) , intent(out) :: rand(:,:,:)
14394 : character(*,SKC) , intent(in) :: lb, ub
14395 : type(splitmix64_type) , intent(inout) :: rng
14396 : end subroutine
14397 : #endif
14398 :
14399 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14400 :
14401 : #if IK5_ENABLED
14402 : PURE module subroutine setUnifRandRNGSLU_D3_IK5(rng, rand, lb, ub)
14403 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14404 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_IK5
14405 : #endif
14406 : use pm_kind, only: IKC => IK5
14407 : integer(IKC) , intent(out) :: rand(:,:,:)
14408 : integer(IKC) , intent(in) :: lb, ub
14409 : type(splitmix64_type) , intent(inout) :: rng
14410 : end subroutine
14411 : #endif
14412 :
14413 : #if IK4_ENABLED
14414 : PURE module subroutine setUnifRandRNGSLU_D3_IK4(rng, rand, lb, ub)
14415 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14416 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_IK4
14417 : #endif
14418 : use pm_kind, only: IKC => IK4
14419 : integer(IKC) , intent(out) :: rand(:,:,:)
14420 : integer(IKC) , intent(in) :: lb, ub
14421 : type(splitmix64_type) , intent(inout) :: rng
14422 : end subroutine
14423 : #endif
14424 :
14425 : #if IK3_ENABLED
14426 : PURE module subroutine setUnifRandRNGSLU_D3_IK3(rng, rand, lb, ub)
14427 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14428 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_IK3
14429 : #endif
14430 : use pm_kind, only: IKC => IK3
14431 : integer(IKC) , intent(out) :: rand(:,:,:)
14432 : integer(IKC) , intent(in) :: lb, ub
14433 : type(splitmix64_type) , intent(inout) :: rng
14434 : end subroutine
14435 : #endif
14436 :
14437 : #if IK2_ENABLED
14438 : PURE module subroutine setUnifRandRNGSLU_D3_IK2(rng, rand, lb, ub)
14439 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14440 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_IK2
14441 : #endif
14442 : use pm_kind, only: IKC => IK2
14443 : integer(IKC) , intent(out) :: rand(:,:,:)
14444 : integer(IKC) , intent(in) :: lb, ub
14445 : type(splitmix64_type) , intent(inout) :: rng
14446 : end subroutine
14447 : #endif
14448 :
14449 : #if IK1_ENABLED
14450 : PURE module subroutine setUnifRandRNGSLU_D3_IK1(rng, rand, lb, ub)
14451 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14452 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_IK1
14453 : #endif
14454 : use pm_kind, only: IKC => IK1
14455 : integer(IKC) , intent(out) :: rand(:,:,:)
14456 : integer(IKC) , intent(in) :: lb, ub
14457 : type(splitmix64_type) , intent(inout) :: rng
14458 : end subroutine
14459 : #endif
14460 :
14461 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14462 :
14463 : #if LK5_ENABLED
14464 : PURE module subroutine setUnifRandRNGSLU_D3_LK5(rng, rand, lb, ub)
14465 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14466 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_LK5
14467 : #endif
14468 : use pm_kind, only: LKC => LK5
14469 : logical(LKC) , intent(out) :: rand(:,:,:)
14470 : logical(LKC) , intent(in) :: lb, ub
14471 : type(splitmix64_type) , intent(inout) :: rng
14472 : end subroutine
14473 : #endif
14474 :
14475 : #if LK4_ENABLED
14476 : PURE module subroutine setUnifRandRNGSLU_D3_LK4(rng, rand, lb, ub)
14477 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14478 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_LK4
14479 : #endif
14480 : use pm_kind, only: LKC => LK4
14481 : logical(LKC) , intent(out) :: rand(:,:,:)
14482 : logical(LKC) , intent(in) :: lb, ub
14483 : type(splitmix64_type) , intent(inout) :: rng
14484 : end subroutine
14485 : #endif
14486 :
14487 : #if LK3_ENABLED
14488 : PURE module subroutine setUnifRandRNGSLU_D3_LK3(rng, rand, lb, ub)
14489 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14490 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_LK3
14491 : #endif
14492 : use pm_kind, only: LKC => LK3
14493 : logical(LKC) , intent(out) :: rand(:,:,:)
14494 : logical(LKC) , intent(in) :: lb, ub
14495 : type(splitmix64_type) , intent(inout) :: rng
14496 : end subroutine
14497 : #endif
14498 :
14499 : #if LK2_ENABLED
14500 : PURE module subroutine setUnifRandRNGSLU_D3_LK2(rng, rand, lb, ub)
14501 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14502 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_LK2
14503 : #endif
14504 : use pm_kind, only: LKC => LK2
14505 : logical(LKC) , intent(out) :: rand(:,:,:)
14506 : logical(LKC) , intent(in) :: lb, ub
14507 : type(splitmix64_type) , intent(inout) :: rng
14508 : end subroutine
14509 : #endif
14510 :
14511 : #if LK1_ENABLED
14512 : PURE module subroutine setUnifRandRNGSLU_D3_LK1(rng, rand, lb, ub)
14513 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14514 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_LK1
14515 : #endif
14516 : use pm_kind, only: LKC => LK1
14517 : logical(LKC) , intent(out) :: rand(:,:,:)
14518 : logical(LKC) , intent(in) :: lb, ub
14519 : type(splitmix64_type) , intent(inout) :: rng
14520 : end subroutine
14521 : #endif
14522 :
14523 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14524 :
14525 : #if CK5_ENABLED
14526 : PURE module subroutine setUnifRandRNGSLU_D3_CK5(rng, rand, lb, ub)
14527 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14528 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_CK5
14529 : #endif
14530 : use pm_kind, only: CKC => CK5
14531 : complex(CKC) , intent(out) :: rand(:,:,:)
14532 : complex(CKC) , intent(in) :: lb, ub
14533 : type(splitmix64_type) , intent(inout) :: rng
14534 : end subroutine
14535 : #endif
14536 :
14537 : #if CK4_ENABLED
14538 : PURE module subroutine setUnifRandRNGSLU_D3_CK4(rng, rand, lb, ub)
14539 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14540 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_CK4
14541 : #endif
14542 : use pm_kind, only: CKC => CK4
14543 : complex(CKC) , intent(out) :: rand(:,:,:)
14544 : complex(CKC) , intent(in) :: lb, ub
14545 : type(splitmix64_type) , intent(inout) :: rng
14546 : end subroutine
14547 : #endif
14548 :
14549 : #if CK3_ENABLED
14550 : PURE module subroutine setUnifRandRNGSLU_D3_CK3(rng, rand, lb, ub)
14551 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14552 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_CK3
14553 : #endif
14554 : use pm_kind, only: CKC => CK3
14555 : complex(CKC) , intent(out) :: rand(:,:,:)
14556 : complex(CKC) , intent(in) :: lb, ub
14557 : type(splitmix64_type) , intent(inout) :: rng
14558 : end subroutine
14559 : #endif
14560 :
14561 : #if CK2_ENABLED
14562 : PURE module subroutine setUnifRandRNGSLU_D3_CK2(rng, rand, lb, ub)
14563 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14564 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_CK2
14565 : #endif
14566 : use pm_kind, only: CKC => CK2
14567 : complex(CKC) , intent(out) :: rand(:,:,:)
14568 : complex(CKC) , intent(in) :: lb, ub
14569 : type(splitmix64_type) , intent(inout) :: rng
14570 : end subroutine
14571 : #endif
14572 :
14573 : #if CK1_ENABLED
14574 : PURE module subroutine setUnifRandRNGSLU_D3_CK1(rng, rand, lb, ub)
14575 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14576 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_CK1
14577 : #endif
14578 : use pm_kind, only: CKC => CK1
14579 : complex(CKC) , intent(out) :: rand(:,:,:)
14580 : complex(CKC) , intent(in) :: lb, ub
14581 : type(splitmix64_type) , intent(inout) :: rng
14582 : end subroutine
14583 : #endif
14584 :
14585 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14586 :
14587 : #if RK5_ENABLED
14588 : PURE module subroutine setUnifRandRNGSLU_D3_RK5(rng, rand, lb, ub)
14589 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14590 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_RK5
14591 : #endif
14592 : use pm_kind, only: RKC => RK5
14593 : real(RKC) , intent(out) :: rand(:,:,:)
14594 : real(RKC) , intent(in) :: lb, ub
14595 : type(splitmix64_type) , intent(inout) :: rng
14596 : end subroutine
14597 : #endif
14598 :
14599 : #if RK4_ENABLED
14600 : PURE module subroutine setUnifRandRNGSLU_D3_RK4(rng, rand, lb, ub)
14601 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14602 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_RK4
14603 : #endif
14604 : use pm_kind, only: RKC => RK4
14605 : real(RKC) , intent(out) :: rand(:,:,:)
14606 : real(RKC) , intent(in) :: lb, ub
14607 : type(splitmix64_type) , intent(inout) :: rng
14608 : end subroutine
14609 : #endif
14610 :
14611 : #if RK3_ENABLED
14612 : PURE module subroutine setUnifRandRNGSLU_D3_RK3(rng, rand, lb, ub)
14613 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14614 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_RK3
14615 : #endif
14616 : use pm_kind, only: RKC => RK3
14617 : real(RKC) , intent(out) :: rand(:,:,:)
14618 : real(RKC) , intent(in) :: lb, ub
14619 : type(splitmix64_type) , intent(inout) :: rng
14620 : end subroutine
14621 : #endif
14622 :
14623 : #if RK2_ENABLED
14624 : PURE module subroutine setUnifRandRNGSLU_D3_RK2(rng, rand, lb, ub)
14625 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14626 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_RK2
14627 : #endif
14628 : use pm_kind, only: RKC => RK2
14629 : real(RKC) , intent(out) :: rand(:,:,:)
14630 : real(RKC) , intent(in) :: lb, ub
14631 : type(splitmix64_type) , intent(inout) :: rng
14632 : end subroutine
14633 : #endif
14634 :
14635 : #if RK1_ENABLED
14636 : PURE module subroutine setUnifRandRNGSLU_D3_RK1(rng, rand, lb, ub)
14637 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14638 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGSLU_D3_RK1
14639 : #endif
14640 : use pm_kind, only: RKC => RK1
14641 : real(RKC) , intent(out) :: rand(:,:,:)
14642 : real(RKC) , intent(in) :: lb, ub
14643 : type(splitmix64_type) , intent(inout) :: rng
14644 : end subroutine
14645 : #endif
14646 :
14647 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14648 :
14649 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14650 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14651 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14652 :
14653 : end interface
14654 :
14655 : ! RNGX
14656 :
14657 : interface setUnifRand
14658 :
14659 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14660 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14661 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14662 :
14663 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14664 :
14665 : #if SK5_ENABLED
14666 : PURE elemental module subroutine setUnifRandRNGGDD_D0_SK5(rng, rand)
14667 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14668 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_SK5
14669 : #endif
14670 : use pm_kind, only: SKC => SK5
14671 : character(*,SKC) , intent(out) :: rand
14672 : type(xoshiro256ssg_type) , intent(inout) :: rng
14673 : end subroutine
14674 : #endif
14675 :
14676 : #if SK4_ENABLED
14677 : PURE elemental module subroutine setUnifRandRNGGDD_D0_SK4(rng, rand)
14678 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14679 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_SK4
14680 : #endif
14681 : use pm_kind, only: SKC => SK4
14682 : character(*,SKC) , intent(out) :: rand
14683 : type(xoshiro256ssg_type) , intent(inout) :: rng
14684 : end subroutine
14685 : #endif
14686 :
14687 : #if SK3_ENABLED
14688 : PURE elemental module subroutine setUnifRandRNGGDD_D0_SK3(rng, rand)
14689 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14690 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_SK3
14691 : #endif
14692 : use pm_kind, only: SKC => SK3
14693 : character(*,SKC) , intent(out) :: rand
14694 : type(xoshiro256ssg_type) , intent(inout) :: rng
14695 : end subroutine
14696 : #endif
14697 :
14698 : #if SK2_ENABLED
14699 : PURE elemental module subroutine setUnifRandRNGGDD_D0_SK2(rng, rand)
14700 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14701 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_SK2
14702 : #endif
14703 : use pm_kind, only: SKC => SK2
14704 : character(*,SKC) , intent(out) :: rand
14705 : type(xoshiro256ssg_type) , intent(inout) :: rng
14706 : end subroutine
14707 : #endif
14708 :
14709 : #if SK1_ENABLED
14710 : PURE elemental module subroutine setUnifRandRNGGDD_D0_SK1(rng, rand)
14711 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14712 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_SK1
14713 : #endif
14714 : use pm_kind, only: SKC => SK1
14715 : character(*,SKC) , intent(out) :: rand
14716 : type(xoshiro256ssg_type) , intent(inout) :: rng
14717 : end subroutine
14718 : #endif
14719 :
14720 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14721 :
14722 : #if IK5_ENABLED
14723 : PURE elemental module subroutine setUnifRandRNGGDD_D0_IK5(rng, rand)
14724 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14725 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_IK5
14726 : #endif
14727 : use pm_kind, only: IKC => IK5
14728 : integer(IKC) , intent(out) :: rand
14729 : type(xoshiro256ssg_type) , intent(inout) :: rng
14730 : end subroutine
14731 : #endif
14732 :
14733 : #if IK4_ENABLED
14734 : PURE elemental module subroutine setUnifRandRNGGDD_D0_IK4(rng, rand)
14735 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14736 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_IK4
14737 : #endif
14738 : use pm_kind, only: IKC => IK4
14739 : integer(IKC) , intent(out) :: rand
14740 : type(xoshiro256ssg_type) , intent(inout) :: rng
14741 : end subroutine
14742 : #endif
14743 :
14744 : #if IK3_ENABLED
14745 : PURE elemental module subroutine setUnifRandRNGGDD_D0_IK3(rng, rand)
14746 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14747 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_IK3
14748 : #endif
14749 : use pm_kind, only: IKC => IK3
14750 : integer(IKC) , intent(out) :: rand
14751 : type(xoshiro256ssg_type) , intent(inout) :: rng
14752 : end subroutine
14753 : #endif
14754 :
14755 : #if IK2_ENABLED
14756 : PURE elemental module subroutine setUnifRandRNGGDD_D0_IK2(rng, rand)
14757 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14758 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_IK2
14759 : #endif
14760 : use pm_kind, only: IKC => IK2
14761 : integer(IKC) , intent(out) :: rand
14762 : type(xoshiro256ssg_type) , intent(inout) :: rng
14763 : end subroutine
14764 : #endif
14765 :
14766 : #if IK1_ENABLED
14767 : PURE elemental module subroutine setUnifRandRNGGDD_D0_IK1(rng, rand)
14768 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14769 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_IK1
14770 : #endif
14771 : use pm_kind, only: IKC => IK1
14772 : integer(IKC) , intent(out) :: rand
14773 : type(xoshiro256ssg_type) , intent(inout) :: rng
14774 : end subroutine
14775 : #endif
14776 :
14777 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14778 :
14779 : #if LK5_ENABLED
14780 : PURE elemental module subroutine setUnifRandRNGGDD_D0_LK5(rng, rand)
14781 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14782 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_LK5
14783 : #endif
14784 : use pm_kind, only: LKC => LK5
14785 : logical(LKC) , intent(out) :: rand
14786 : type(xoshiro256ssg_type) , intent(inout) :: rng
14787 : end subroutine
14788 : #endif
14789 :
14790 : #if LK4_ENABLED
14791 : PURE elemental module subroutine setUnifRandRNGGDD_D0_LK4(rng, rand)
14792 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14793 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_LK4
14794 : #endif
14795 : use pm_kind, only: LKC => LK4
14796 : logical(LKC) , intent(out) :: rand
14797 : type(xoshiro256ssg_type) , intent(inout) :: rng
14798 : end subroutine
14799 : #endif
14800 :
14801 : #if LK3_ENABLED
14802 : PURE elemental module subroutine setUnifRandRNGGDD_D0_LK3(rng, rand)
14803 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14804 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_LK3
14805 : #endif
14806 : use pm_kind, only: LKC => LK3
14807 : logical(LKC) , intent(out) :: rand
14808 : type(xoshiro256ssg_type) , intent(inout) :: rng
14809 : end subroutine
14810 : #endif
14811 :
14812 : #if LK2_ENABLED
14813 : PURE elemental module subroutine setUnifRandRNGGDD_D0_LK2(rng, rand)
14814 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14815 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_LK2
14816 : #endif
14817 : use pm_kind, only: LKC => LK2
14818 : logical(LKC) , intent(out) :: rand
14819 : type(xoshiro256ssg_type) , intent(inout) :: rng
14820 : end subroutine
14821 : #endif
14822 :
14823 : #if LK1_ENABLED
14824 : PURE elemental module subroutine setUnifRandRNGGDD_D0_LK1(rng, rand)
14825 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14826 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_LK1
14827 : #endif
14828 : use pm_kind, only: LKC => LK1
14829 : logical(LKC) , intent(out) :: rand
14830 : type(xoshiro256ssg_type) , intent(inout) :: rng
14831 : end subroutine
14832 : #endif
14833 :
14834 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14835 :
14836 : #if CK5_ENABLED
14837 : PURE elemental module subroutine setUnifRandRNGGDD_D0_CK5(rng, rand)
14838 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14839 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_CK5
14840 : #endif
14841 : use pm_kind, only: CKC => CK5
14842 : complex(CKC) , intent(out) :: rand
14843 : type(xoshiro256ssg_type) , intent(inout) :: rng
14844 : end subroutine
14845 : #endif
14846 :
14847 : #if CK4_ENABLED
14848 : PURE elemental module subroutine setUnifRandRNGGDD_D0_CK4(rng, rand)
14849 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14850 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_CK4
14851 : #endif
14852 : use pm_kind, only: CKC => CK4
14853 : complex(CKC) , intent(out) :: rand
14854 : type(xoshiro256ssg_type) , intent(inout) :: rng
14855 : end subroutine
14856 : #endif
14857 :
14858 : #if CK3_ENABLED
14859 : PURE elemental module subroutine setUnifRandRNGGDD_D0_CK3(rng, rand)
14860 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14861 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_CK3
14862 : #endif
14863 : use pm_kind, only: CKC => CK3
14864 : complex(CKC) , intent(out) :: rand
14865 : type(xoshiro256ssg_type) , intent(inout) :: rng
14866 : end subroutine
14867 : #endif
14868 :
14869 : #if CK2_ENABLED
14870 : PURE elemental module subroutine setUnifRandRNGGDD_D0_CK2(rng, rand)
14871 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14872 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_CK2
14873 : #endif
14874 : use pm_kind, only: CKC => CK2
14875 : complex(CKC) , intent(out) :: rand
14876 : type(xoshiro256ssg_type) , intent(inout) :: rng
14877 : end subroutine
14878 : #endif
14879 :
14880 : #if CK1_ENABLED
14881 : PURE elemental module subroutine setUnifRandRNGGDD_D0_CK1(rng, rand)
14882 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14883 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_CK1
14884 : #endif
14885 : use pm_kind, only: CKC => CK1
14886 : complex(CKC) , intent(out) :: rand
14887 : type(xoshiro256ssg_type) , intent(inout) :: rng
14888 : end subroutine
14889 : #endif
14890 :
14891 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14892 :
14893 : #if RK5_ENABLED
14894 : PURE elemental module subroutine setUnifRandRNGGDD_D0_RK5(rng, rand)
14895 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14896 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_RK5
14897 : #endif
14898 : use pm_kind, only: RKC => RK5
14899 : real(RKC) , intent(out) :: rand
14900 : type(xoshiro256ssg_type) , intent(inout) :: rng
14901 : end subroutine
14902 : #endif
14903 :
14904 : #if RK4_ENABLED
14905 : PURE elemental module subroutine setUnifRandRNGGDD_D0_RK4(rng, rand)
14906 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14907 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_RK4
14908 : #endif
14909 : use pm_kind, only: RKC => RK4
14910 : real(RKC) , intent(out) :: rand
14911 : type(xoshiro256ssg_type) , intent(inout) :: rng
14912 : end subroutine
14913 : #endif
14914 :
14915 : #if RK3_ENABLED
14916 : PURE elemental module subroutine setUnifRandRNGGDD_D0_RK3(rng, rand)
14917 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14918 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_RK3
14919 : #endif
14920 : use pm_kind, only: RKC => RK3
14921 : real(RKC) , intent(out) :: rand
14922 : type(xoshiro256ssg_type) , intent(inout) :: rng
14923 : end subroutine
14924 : #endif
14925 :
14926 : #if RK2_ENABLED
14927 : PURE elemental module subroutine setUnifRandRNGGDD_D0_RK2(rng, rand)
14928 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14929 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_RK2
14930 : #endif
14931 : use pm_kind, only: RKC => RK2
14932 : real(RKC) , intent(out) :: rand
14933 : type(xoshiro256ssg_type) , intent(inout) :: rng
14934 : end subroutine
14935 : #endif
14936 :
14937 : #if RK1_ENABLED
14938 : PURE elemental module subroutine setUnifRandRNGGDD_D0_RK1(rng, rand)
14939 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14940 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D0_RK1
14941 : #endif
14942 : use pm_kind, only: RKC => RK1
14943 : real(RKC) , intent(out) :: rand
14944 : type(xoshiro256ssg_type) , intent(inout) :: rng
14945 : end subroutine
14946 : #endif
14947 :
14948 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14949 :
14950 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14951 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14952 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14953 :
14954 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
14955 :
14956 : #if SK5_ENABLED
14957 : PURE elemental module subroutine setUnifRandRNGGLU_D0_SK5(rng, rand, lb, ub)
14958 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14959 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_SK5
14960 : #endif
14961 : use pm_kind, only: SKC => SK5
14962 : character(*,SKC) , intent(out) :: rand
14963 : character(*,SKC) , intent(in) :: lb, ub
14964 : type(xoshiro256ssg_type) , intent(inout) :: rng
14965 : end subroutine
14966 : #endif
14967 :
14968 : #if SK4_ENABLED
14969 : PURE elemental module subroutine setUnifRandRNGGLU_D0_SK4(rng, rand, lb, ub)
14970 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14971 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_SK4
14972 : #endif
14973 : use pm_kind, only: SKC => SK4
14974 : character(*,SKC) , intent(out) :: rand
14975 : character(*,SKC) , intent(in) :: lb, ub
14976 : type(xoshiro256ssg_type) , intent(inout) :: rng
14977 : end subroutine
14978 : #endif
14979 :
14980 : #if SK3_ENABLED
14981 : PURE elemental module subroutine setUnifRandRNGGLU_D0_SK3(rng, rand, lb, ub)
14982 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14983 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_SK3
14984 : #endif
14985 : use pm_kind, only: SKC => SK3
14986 : character(*,SKC) , intent(out) :: rand
14987 : character(*,SKC) , intent(in) :: lb, ub
14988 : type(xoshiro256ssg_type) , intent(inout) :: rng
14989 : end subroutine
14990 : #endif
14991 :
14992 : #if SK2_ENABLED
14993 : PURE elemental module subroutine setUnifRandRNGGLU_D0_SK2(rng, rand, lb, ub)
14994 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
14995 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_SK2
14996 : #endif
14997 : use pm_kind, only: SKC => SK2
14998 : character(*,SKC) , intent(out) :: rand
14999 : character(*,SKC) , intent(in) :: lb, ub
15000 : type(xoshiro256ssg_type) , intent(inout) :: rng
15001 : end subroutine
15002 : #endif
15003 :
15004 : #if SK1_ENABLED
15005 : PURE elemental module subroutine setUnifRandRNGGLU_D0_SK1(rng, rand, lb, ub)
15006 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15007 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_SK1
15008 : #endif
15009 : use pm_kind, only: SKC => SK1
15010 : character(*,SKC) , intent(out) :: rand
15011 : character(*,SKC) , intent(in) :: lb, ub
15012 : type(xoshiro256ssg_type) , intent(inout) :: rng
15013 : end subroutine
15014 : #endif
15015 :
15016 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15017 :
15018 : #if IK5_ENABLED
15019 : PURE elemental module subroutine setUnifRandRNGGLU_D0_IK5(rng, rand, lb, ub)
15020 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15021 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_IK5
15022 : #endif
15023 : use pm_kind, only: IKC => IK5
15024 : integer(IKC) , intent(out) :: rand
15025 : integer(IKC) , intent(in) :: lb, ub
15026 : type(xoshiro256ssg_type) , intent(inout) :: rng
15027 : end subroutine
15028 : #endif
15029 :
15030 : #if IK4_ENABLED
15031 : PURE elemental module subroutine setUnifRandRNGGLU_D0_IK4(rng, rand, lb, ub)
15032 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15033 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_IK4
15034 : #endif
15035 : use pm_kind, only: IKC => IK4
15036 : integer(IKC) , intent(out) :: rand
15037 : integer(IKC) , intent(in) :: lb, ub
15038 : type(xoshiro256ssg_type) , intent(inout) :: rng
15039 : end subroutine
15040 : #endif
15041 :
15042 : #if IK3_ENABLED
15043 : PURE elemental module subroutine setUnifRandRNGGLU_D0_IK3(rng, rand, lb, ub)
15044 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15045 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_IK3
15046 : #endif
15047 : use pm_kind, only: IKC => IK3
15048 : integer(IKC) , intent(out) :: rand
15049 : integer(IKC) , intent(in) :: lb, ub
15050 : type(xoshiro256ssg_type) , intent(inout) :: rng
15051 : end subroutine
15052 : #endif
15053 :
15054 : #if IK2_ENABLED
15055 : PURE elemental module subroutine setUnifRandRNGGLU_D0_IK2(rng, rand, lb, ub)
15056 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15057 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_IK2
15058 : #endif
15059 : use pm_kind, only: IKC => IK2
15060 : integer(IKC) , intent(out) :: rand
15061 : integer(IKC) , intent(in) :: lb, ub
15062 : type(xoshiro256ssg_type) , intent(inout) :: rng
15063 : end subroutine
15064 : #endif
15065 :
15066 : #if IK1_ENABLED
15067 : PURE elemental module subroutine setUnifRandRNGGLU_D0_IK1(rng, rand, lb, ub)
15068 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15069 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_IK1
15070 : #endif
15071 : use pm_kind, only: IKC => IK1
15072 : integer(IKC) , intent(out) :: rand
15073 : integer(IKC) , intent(in) :: lb, ub
15074 : type(xoshiro256ssg_type) , intent(inout) :: rng
15075 : end subroutine
15076 : #endif
15077 :
15078 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15079 :
15080 : #if LK5_ENABLED
15081 : PURE elemental module subroutine setUnifRandRNGGLU_D0_LK5(rng, rand, lb, ub)
15082 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15083 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_LK5
15084 : #endif
15085 : use pm_kind, only: LKC => LK5
15086 : logical(LKC) , intent(out) :: rand
15087 : logical(LKC) , intent(in) :: lb, ub
15088 : type(xoshiro256ssg_type) , intent(inout) :: rng
15089 : end subroutine
15090 : #endif
15091 :
15092 : #if LK4_ENABLED
15093 : PURE elemental module subroutine setUnifRandRNGGLU_D0_LK4(rng, rand, lb, ub)
15094 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15095 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_LK4
15096 : #endif
15097 : use pm_kind, only: LKC => LK4
15098 : logical(LKC) , intent(out) :: rand
15099 : logical(LKC) , intent(in) :: lb, ub
15100 : type(xoshiro256ssg_type) , intent(inout) :: rng
15101 : end subroutine
15102 : #endif
15103 :
15104 : #if LK3_ENABLED
15105 : PURE elemental module subroutine setUnifRandRNGGLU_D0_LK3(rng, rand, lb, ub)
15106 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15107 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_LK3
15108 : #endif
15109 : use pm_kind, only: LKC => LK3
15110 : logical(LKC) , intent(out) :: rand
15111 : logical(LKC) , intent(in) :: lb, ub
15112 : type(xoshiro256ssg_type) , intent(inout) :: rng
15113 : end subroutine
15114 : #endif
15115 :
15116 : #if LK2_ENABLED
15117 : PURE elemental module subroutine setUnifRandRNGGLU_D0_LK2(rng, rand, lb, ub)
15118 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15119 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_LK2
15120 : #endif
15121 : use pm_kind, only: LKC => LK2
15122 : logical(LKC) , intent(out) :: rand
15123 : logical(LKC) , intent(in) :: lb, ub
15124 : type(xoshiro256ssg_type) , intent(inout) :: rng
15125 : end subroutine
15126 : #endif
15127 :
15128 : #if LK1_ENABLED
15129 : PURE elemental module subroutine setUnifRandRNGGLU_D0_LK1(rng, rand, lb, ub)
15130 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15131 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_LK1
15132 : #endif
15133 : use pm_kind, only: LKC => LK1
15134 : logical(LKC) , intent(out) :: rand
15135 : logical(LKC) , intent(in) :: lb, ub
15136 : type(xoshiro256ssg_type) , intent(inout) :: rng
15137 : end subroutine
15138 : #endif
15139 :
15140 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15141 :
15142 : #if CK5_ENABLED
15143 : PURE elemental module subroutine setUnifRandRNGGLU_D0_CK5(rng, rand, lb, ub)
15144 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15145 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_CK5
15146 : #endif
15147 : use pm_kind, only: CKC => CK5
15148 : complex(CKC) , intent(out) :: rand
15149 : complex(CKC) , intent(in) :: lb, ub
15150 : type(xoshiro256ssg_type) , intent(inout) :: rng
15151 : end subroutine
15152 : #endif
15153 :
15154 : #if CK4_ENABLED
15155 : PURE elemental module subroutine setUnifRandRNGGLU_D0_CK4(rng, rand, lb, ub)
15156 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15157 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_CK4
15158 : #endif
15159 : use pm_kind, only: CKC => CK4
15160 : complex(CKC) , intent(out) :: rand
15161 : complex(CKC) , intent(in) :: lb, ub
15162 : type(xoshiro256ssg_type) , intent(inout) :: rng
15163 : end subroutine
15164 : #endif
15165 :
15166 : #if CK3_ENABLED
15167 : PURE elemental module subroutine setUnifRandRNGGLU_D0_CK3(rng, rand, lb, ub)
15168 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15169 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_CK3
15170 : #endif
15171 : use pm_kind, only: CKC => CK3
15172 : complex(CKC) , intent(out) :: rand
15173 : complex(CKC) , intent(in) :: lb, ub
15174 : type(xoshiro256ssg_type) , intent(inout) :: rng
15175 : end subroutine
15176 : #endif
15177 :
15178 : #if CK2_ENABLED
15179 : PURE elemental module subroutine setUnifRandRNGGLU_D0_CK2(rng, rand, lb, ub)
15180 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15181 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_CK2
15182 : #endif
15183 : use pm_kind, only: CKC => CK2
15184 : complex(CKC) , intent(out) :: rand
15185 : complex(CKC) , intent(in) :: lb, ub
15186 : type(xoshiro256ssg_type) , intent(inout) :: rng
15187 : end subroutine
15188 : #endif
15189 :
15190 : #if CK1_ENABLED
15191 : PURE elemental module subroutine setUnifRandRNGGLU_D0_CK1(rng, rand, lb, ub)
15192 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15193 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_CK1
15194 : #endif
15195 : use pm_kind, only: CKC => CK1
15196 : complex(CKC) , intent(out) :: rand
15197 : complex(CKC) , intent(in) :: lb, ub
15198 : type(xoshiro256ssg_type) , intent(inout) :: rng
15199 : end subroutine
15200 : #endif
15201 :
15202 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15203 :
15204 : #if RK5_ENABLED
15205 : PURE elemental module subroutine setUnifRandRNGGLU_D0_RK5(rng, rand, lb, ub)
15206 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15207 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_RK5
15208 : #endif
15209 : use pm_kind, only: RKC => RK5
15210 : real(RKC) , intent(out) :: rand
15211 : real(RKC) , intent(in) :: lb, ub
15212 : type(xoshiro256ssg_type) , intent(inout) :: rng
15213 : end subroutine
15214 : #endif
15215 :
15216 : #if RK4_ENABLED
15217 : PURE elemental module subroutine setUnifRandRNGGLU_D0_RK4(rng, rand, lb, ub)
15218 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15219 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_RK4
15220 : #endif
15221 : use pm_kind, only: RKC => RK4
15222 : real(RKC) , intent(out) :: rand
15223 : real(RKC) , intent(in) :: lb, ub
15224 : type(xoshiro256ssg_type) , intent(inout) :: rng
15225 : end subroutine
15226 : #endif
15227 :
15228 : #if RK3_ENABLED
15229 : PURE elemental module subroutine setUnifRandRNGGLU_D0_RK3(rng, rand, lb, ub)
15230 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15231 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_RK3
15232 : #endif
15233 : use pm_kind, only: RKC => RK3
15234 : real(RKC) , intent(out) :: rand
15235 : real(RKC) , intent(in) :: lb, ub
15236 : type(xoshiro256ssg_type) , intent(inout) :: rng
15237 : end subroutine
15238 : #endif
15239 :
15240 : #if RK2_ENABLED
15241 : PURE elemental module subroutine setUnifRandRNGGLU_D0_RK2(rng, rand, lb, ub)
15242 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15243 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_RK2
15244 : #endif
15245 : use pm_kind, only: RKC => RK2
15246 : real(RKC) , intent(out) :: rand
15247 : real(RKC) , intent(in) :: lb, ub
15248 : type(xoshiro256ssg_type) , intent(inout) :: rng
15249 : end subroutine
15250 : #endif
15251 :
15252 : #if RK1_ENABLED
15253 : PURE elemental module subroutine setUnifRandRNGGLU_D0_RK1(rng, rand, lb, ub)
15254 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15255 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D0_RK1
15256 : #endif
15257 : use pm_kind, only: RKC => RK1
15258 : real(RKC) , intent(out) :: rand
15259 : real(RKC) , intent(in) :: lb, ub
15260 : type(xoshiro256ssg_type) , intent(inout) :: rng
15261 : end subroutine
15262 : #endif
15263 :
15264 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15265 :
15266 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15267 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15268 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15269 :
15270 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15271 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15272 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15273 :
15274 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15275 :
15276 : #if SK5_ENABLED
15277 : PURE module subroutine setUnifRandRNGGDD_D1_SK5(rng, rand)
15278 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15279 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_SK5
15280 : #endif
15281 : use pm_kind, only: SKC => SK5
15282 : character(*,SKC) , intent(out) :: rand(:)
15283 : type(xoshiro256ssg_type) , intent(inout) :: rng
15284 : end subroutine
15285 : #endif
15286 :
15287 : #if SK4_ENABLED
15288 : PURE module subroutine setUnifRandRNGGDD_D1_SK4(rng, rand)
15289 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15290 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_SK4
15291 : #endif
15292 : use pm_kind, only: SKC => SK4
15293 : character(*,SKC) , intent(out) :: rand(:)
15294 : type(xoshiro256ssg_type) , intent(inout) :: rng
15295 : end subroutine
15296 : #endif
15297 :
15298 : #if SK3_ENABLED
15299 : PURE module subroutine setUnifRandRNGGDD_D1_SK3(rng, rand)
15300 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15301 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_SK3
15302 : #endif
15303 : use pm_kind, only: SKC => SK3
15304 : character(*,SKC) , intent(out) :: rand(:)
15305 : type(xoshiro256ssg_type) , intent(inout) :: rng
15306 : end subroutine
15307 : #endif
15308 :
15309 : #if SK2_ENABLED
15310 : PURE module subroutine setUnifRandRNGGDD_D1_SK2(rng, rand)
15311 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15312 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_SK2
15313 : #endif
15314 : use pm_kind, only: SKC => SK2
15315 : character(*,SKC) , intent(out) :: rand(:)
15316 : type(xoshiro256ssg_type) , intent(inout) :: rng
15317 : end subroutine
15318 : #endif
15319 :
15320 : #if SK1_ENABLED
15321 : PURE module subroutine setUnifRandRNGGDD_D1_SK1(rng, rand)
15322 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15323 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_SK1
15324 : #endif
15325 : use pm_kind, only: SKC => SK1
15326 : character(*,SKC) , intent(out) :: rand(:)
15327 : type(xoshiro256ssg_type) , intent(inout) :: rng
15328 : end subroutine
15329 : #endif
15330 :
15331 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15332 :
15333 : #if IK5_ENABLED
15334 : PURE module subroutine setUnifRandRNGGDD_D1_IK5(rng, rand)
15335 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15336 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_IK5
15337 : #endif
15338 : use pm_kind, only: IKC => IK5
15339 : integer(IKC) , intent(out) :: rand(:)
15340 : type(xoshiro256ssg_type) , intent(inout) :: rng
15341 : end subroutine
15342 : #endif
15343 :
15344 : #if IK4_ENABLED
15345 : PURE module subroutine setUnifRandRNGGDD_D1_IK4(rng, rand)
15346 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15347 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_IK4
15348 : #endif
15349 : use pm_kind, only: IKC => IK4
15350 : integer(IKC) , intent(out) :: rand(:)
15351 : type(xoshiro256ssg_type) , intent(inout) :: rng
15352 : end subroutine
15353 : #endif
15354 :
15355 : #if IK3_ENABLED
15356 : PURE module subroutine setUnifRandRNGGDD_D1_IK3(rng, rand)
15357 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15358 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_IK3
15359 : #endif
15360 : use pm_kind, only: IKC => IK3
15361 : integer(IKC) , intent(out) :: rand(:)
15362 : type(xoshiro256ssg_type) , intent(inout) :: rng
15363 : end subroutine
15364 : #endif
15365 :
15366 : #if IK2_ENABLED
15367 : PURE module subroutine setUnifRandRNGGDD_D1_IK2(rng, rand)
15368 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15369 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_IK2
15370 : #endif
15371 : use pm_kind, only: IKC => IK2
15372 : integer(IKC) , intent(out) :: rand(:)
15373 : type(xoshiro256ssg_type) , intent(inout) :: rng
15374 : end subroutine
15375 : #endif
15376 :
15377 : #if IK1_ENABLED
15378 : PURE module subroutine setUnifRandRNGGDD_D1_IK1(rng, rand)
15379 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15380 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_IK1
15381 : #endif
15382 : use pm_kind, only: IKC => IK1
15383 : integer(IKC) , intent(out) :: rand(:)
15384 : type(xoshiro256ssg_type) , intent(inout) :: rng
15385 : end subroutine
15386 : #endif
15387 :
15388 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15389 :
15390 : #if LK5_ENABLED
15391 : PURE module subroutine setUnifRandRNGGDD_D1_LK5(rng, rand)
15392 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15393 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_LK5
15394 : #endif
15395 : use pm_kind, only: LKC => LK5
15396 : logical(LKC) , intent(out) :: rand(:)
15397 : type(xoshiro256ssg_type) , intent(inout) :: rng
15398 : end subroutine
15399 : #endif
15400 :
15401 : #if LK4_ENABLED
15402 : PURE module subroutine setUnifRandRNGGDD_D1_LK4(rng, rand)
15403 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15404 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_LK4
15405 : #endif
15406 : use pm_kind, only: LKC => LK4
15407 : logical(LKC) , intent(out) :: rand(:)
15408 : type(xoshiro256ssg_type) , intent(inout) :: rng
15409 : end subroutine
15410 : #endif
15411 :
15412 : #if LK3_ENABLED
15413 : PURE module subroutine setUnifRandRNGGDD_D1_LK3(rng, rand)
15414 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15415 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_LK3
15416 : #endif
15417 : use pm_kind, only: LKC => LK3
15418 : logical(LKC) , intent(out) :: rand(:)
15419 : type(xoshiro256ssg_type) , intent(inout) :: rng
15420 : end subroutine
15421 : #endif
15422 :
15423 : #if LK2_ENABLED
15424 : PURE module subroutine setUnifRandRNGGDD_D1_LK2(rng, rand)
15425 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15426 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_LK2
15427 : #endif
15428 : use pm_kind, only: LKC => LK2
15429 : logical(LKC) , intent(out) :: rand(:)
15430 : type(xoshiro256ssg_type) , intent(inout) :: rng
15431 : end subroutine
15432 : #endif
15433 :
15434 : #if LK1_ENABLED
15435 : PURE module subroutine setUnifRandRNGGDD_D1_LK1(rng, rand)
15436 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15437 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_LK1
15438 : #endif
15439 : use pm_kind, only: LKC => LK1
15440 : logical(LKC) , intent(out) :: rand(:)
15441 : type(xoshiro256ssg_type) , intent(inout) :: rng
15442 : end subroutine
15443 : #endif
15444 :
15445 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15446 :
15447 : #if CK5_ENABLED
15448 : PURE module subroutine setUnifRandRNGGDD_D1_CK5(rng, rand)
15449 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15450 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_CK5
15451 : #endif
15452 : use pm_kind, only: CKC => CK5
15453 : complex(CKC) , intent(out) :: rand(:)
15454 : type(xoshiro256ssg_type) , intent(inout) :: rng
15455 : end subroutine
15456 : #endif
15457 :
15458 : #if CK4_ENABLED
15459 : PURE module subroutine setUnifRandRNGGDD_D1_CK4(rng, rand)
15460 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15461 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_CK4
15462 : #endif
15463 : use pm_kind, only: CKC => CK4
15464 : complex(CKC) , intent(out) :: rand(:)
15465 : type(xoshiro256ssg_type) , intent(inout) :: rng
15466 : end subroutine
15467 : #endif
15468 :
15469 : #if CK3_ENABLED
15470 : PURE module subroutine setUnifRandRNGGDD_D1_CK3(rng, rand)
15471 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15472 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_CK3
15473 : #endif
15474 : use pm_kind, only: CKC => CK3
15475 : complex(CKC) , intent(out) :: rand(:)
15476 : type(xoshiro256ssg_type) , intent(inout) :: rng
15477 : end subroutine
15478 : #endif
15479 :
15480 : #if CK2_ENABLED
15481 : PURE module subroutine setUnifRandRNGGDD_D1_CK2(rng, rand)
15482 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15483 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_CK2
15484 : #endif
15485 : use pm_kind, only: CKC => CK2
15486 : complex(CKC) , intent(out) :: rand(:)
15487 : type(xoshiro256ssg_type) , intent(inout) :: rng
15488 : end subroutine
15489 : #endif
15490 :
15491 : #if CK1_ENABLED
15492 : PURE module subroutine setUnifRandRNGGDD_D1_CK1(rng, rand)
15493 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15494 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_CK1
15495 : #endif
15496 : use pm_kind, only: CKC => CK1
15497 : complex(CKC) , intent(out) :: rand(:)
15498 : type(xoshiro256ssg_type) , intent(inout) :: rng
15499 : end subroutine
15500 : #endif
15501 :
15502 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15503 :
15504 : #if RK5_ENABLED
15505 : PURE module subroutine setUnifRandRNGGDD_D1_RK5(rng, rand)
15506 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15507 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_RK5
15508 : #endif
15509 : use pm_kind, only: RKC => RK5
15510 : real(RKC) , intent(out) :: rand(:)
15511 : type(xoshiro256ssg_type) , intent(inout) :: rng
15512 : end subroutine
15513 : #endif
15514 :
15515 : #if RK4_ENABLED
15516 : PURE module subroutine setUnifRandRNGGDD_D1_RK4(rng, rand)
15517 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15518 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_RK4
15519 : #endif
15520 : use pm_kind, only: RKC => RK4
15521 : real(RKC) , intent(out) :: rand(:)
15522 : type(xoshiro256ssg_type) , intent(inout) :: rng
15523 : end subroutine
15524 : #endif
15525 :
15526 : #if RK3_ENABLED
15527 : PURE module subroutine setUnifRandRNGGDD_D1_RK3(rng, rand)
15528 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15529 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_RK3
15530 : #endif
15531 : use pm_kind, only: RKC => RK3
15532 : real(RKC) , intent(out) :: rand(:)
15533 : type(xoshiro256ssg_type) , intent(inout) :: rng
15534 : end subroutine
15535 : #endif
15536 :
15537 : #if RK2_ENABLED
15538 : PURE module subroutine setUnifRandRNGGDD_D1_RK2(rng, rand)
15539 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15540 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_RK2
15541 : #endif
15542 : use pm_kind, only: RKC => RK2
15543 : real(RKC) , intent(out) :: rand(:)
15544 : type(xoshiro256ssg_type) , intent(inout) :: rng
15545 : end subroutine
15546 : #endif
15547 :
15548 : #if RK1_ENABLED
15549 : PURE module subroutine setUnifRandRNGGDD_D1_RK1(rng, rand)
15550 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15551 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D1_RK1
15552 : #endif
15553 : use pm_kind, only: RKC => RK1
15554 : real(RKC) , intent(out) :: rand(:)
15555 : type(xoshiro256ssg_type) , intent(inout) :: rng
15556 : end subroutine
15557 : #endif
15558 :
15559 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15560 :
15561 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15562 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15563 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15564 :
15565 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15566 :
15567 : #if SK5_ENABLED
15568 : PURE module subroutine setUnifRandRNGGLU_D1_SK5(rng, rand, lb, ub)
15569 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15570 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_SK5
15571 : #endif
15572 : use pm_kind, only: SKC => SK5
15573 : character(*,SKC) , intent(out) :: rand(:)
15574 : character(*,SKC) , intent(in) :: lb, ub
15575 : type(xoshiro256ssg_type) , intent(inout) :: rng
15576 : end subroutine
15577 : #endif
15578 :
15579 : #if SK4_ENABLED
15580 : PURE module subroutine setUnifRandRNGGLU_D1_SK4(rng, rand, lb, ub)
15581 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15582 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_SK4
15583 : #endif
15584 : use pm_kind, only: SKC => SK4
15585 : character(*,SKC) , intent(out) :: rand(:)
15586 : character(*,SKC) , intent(in) :: lb, ub
15587 : type(xoshiro256ssg_type) , intent(inout) :: rng
15588 : end subroutine
15589 : #endif
15590 :
15591 : #if SK3_ENABLED
15592 : PURE module subroutine setUnifRandRNGGLU_D1_SK3(rng, rand, lb, ub)
15593 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15594 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_SK3
15595 : #endif
15596 : use pm_kind, only: SKC => SK3
15597 : character(*,SKC) , intent(out) :: rand(:)
15598 : character(*,SKC) , intent(in) :: lb, ub
15599 : type(xoshiro256ssg_type) , intent(inout) :: rng
15600 : end subroutine
15601 : #endif
15602 :
15603 : #if SK2_ENABLED
15604 : PURE module subroutine setUnifRandRNGGLU_D1_SK2(rng, rand, lb, ub)
15605 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15606 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_SK2
15607 : #endif
15608 : use pm_kind, only: SKC => SK2
15609 : character(*,SKC) , intent(out) :: rand(:)
15610 : character(*,SKC) , intent(in) :: lb, ub
15611 : type(xoshiro256ssg_type) , intent(inout) :: rng
15612 : end subroutine
15613 : #endif
15614 :
15615 : #if SK1_ENABLED
15616 : PURE module subroutine setUnifRandRNGGLU_D1_SK1(rng, rand, lb, ub)
15617 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15618 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_SK1
15619 : #endif
15620 : use pm_kind, only: SKC => SK1
15621 : character(*,SKC) , intent(out) :: rand(:)
15622 : character(*,SKC) , intent(in) :: lb, ub
15623 : type(xoshiro256ssg_type) , intent(inout) :: rng
15624 : end subroutine
15625 : #endif
15626 :
15627 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15628 :
15629 : #if IK5_ENABLED
15630 : PURE module subroutine setUnifRandRNGGLU_D1_IK5(rng, rand, lb, ub)
15631 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15632 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_IK5
15633 : #endif
15634 : use pm_kind, only: IKC => IK5
15635 : integer(IKC) , intent(out) :: rand(:)
15636 : integer(IKC) , intent(in) :: lb, ub
15637 : type(xoshiro256ssg_type) , intent(inout) :: rng
15638 : end subroutine
15639 : #endif
15640 :
15641 : #if IK4_ENABLED
15642 : PURE module subroutine setUnifRandRNGGLU_D1_IK4(rng, rand, lb, ub)
15643 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15644 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_IK4
15645 : #endif
15646 : use pm_kind, only: IKC => IK4
15647 : integer(IKC) , intent(out) :: rand(:)
15648 : integer(IKC) , intent(in) :: lb, ub
15649 : type(xoshiro256ssg_type) , intent(inout) :: rng
15650 : end subroutine
15651 : #endif
15652 :
15653 : #if IK3_ENABLED
15654 : PURE module subroutine setUnifRandRNGGLU_D1_IK3(rng, rand, lb, ub)
15655 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15656 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_IK3
15657 : #endif
15658 : use pm_kind, only: IKC => IK3
15659 : integer(IKC) , intent(out) :: rand(:)
15660 : integer(IKC) , intent(in) :: lb, ub
15661 : type(xoshiro256ssg_type) , intent(inout) :: rng
15662 : end subroutine
15663 : #endif
15664 :
15665 : #if IK2_ENABLED
15666 : PURE module subroutine setUnifRandRNGGLU_D1_IK2(rng, rand, lb, ub)
15667 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15668 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_IK2
15669 : #endif
15670 : use pm_kind, only: IKC => IK2
15671 : integer(IKC) , intent(out) :: rand(:)
15672 : integer(IKC) , intent(in) :: lb, ub
15673 : type(xoshiro256ssg_type) , intent(inout) :: rng
15674 : end subroutine
15675 : #endif
15676 :
15677 : #if IK1_ENABLED
15678 : PURE module subroutine setUnifRandRNGGLU_D1_IK1(rng, rand, lb, ub)
15679 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15680 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_IK1
15681 : #endif
15682 : use pm_kind, only: IKC => IK1
15683 : integer(IKC) , intent(out) :: rand(:)
15684 : integer(IKC) , intent(in) :: lb, ub
15685 : type(xoshiro256ssg_type) , intent(inout) :: rng
15686 : end subroutine
15687 : #endif
15688 :
15689 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15690 :
15691 : #if LK5_ENABLED
15692 : PURE module subroutine setUnifRandRNGGLU_D1_LK5(rng, rand, lb, ub)
15693 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15694 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_LK5
15695 : #endif
15696 : use pm_kind, only: LKC => LK5
15697 : logical(LKC) , intent(out) :: rand(:)
15698 : logical(LKC) , intent(in) :: lb, ub
15699 : type(xoshiro256ssg_type) , intent(inout) :: rng
15700 : end subroutine
15701 : #endif
15702 :
15703 : #if LK4_ENABLED
15704 : PURE module subroutine setUnifRandRNGGLU_D1_LK4(rng, rand, lb, ub)
15705 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15706 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_LK4
15707 : #endif
15708 : use pm_kind, only: LKC => LK4
15709 : logical(LKC) , intent(out) :: rand(:)
15710 : logical(LKC) , intent(in) :: lb, ub
15711 : type(xoshiro256ssg_type) , intent(inout) :: rng
15712 : end subroutine
15713 : #endif
15714 :
15715 : #if LK3_ENABLED
15716 : PURE module subroutine setUnifRandRNGGLU_D1_LK3(rng, rand, lb, ub)
15717 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15718 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_LK3
15719 : #endif
15720 : use pm_kind, only: LKC => LK3
15721 : logical(LKC) , intent(out) :: rand(:)
15722 : logical(LKC) , intent(in) :: lb, ub
15723 : type(xoshiro256ssg_type) , intent(inout) :: rng
15724 : end subroutine
15725 : #endif
15726 :
15727 : #if LK2_ENABLED
15728 : PURE module subroutine setUnifRandRNGGLU_D1_LK2(rng, rand, lb, ub)
15729 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15730 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_LK2
15731 : #endif
15732 : use pm_kind, only: LKC => LK2
15733 : logical(LKC) , intent(out) :: rand(:)
15734 : logical(LKC) , intent(in) :: lb, ub
15735 : type(xoshiro256ssg_type) , intent(inout) :: rng
15736 : end subroutine
15737 : #endif
15738 :
15739 : #if LK1_ENABLED
15740 : PURE module subroutine setUnifRandRNGGLU_D1_LK1(rng, rand, lb, ub)
15741 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15742 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_LK1
15743 : #endif
15744 : use pm_kind, only: LKC => LK1
15745 : logical(LKC) , intent(out) :: rand(:)
15746 : logical(LKC) , intent(in) :: lb, ub
15747 : type(xoshiro256ssg_type) , intent(inout) :: rng
15748 : end subroutine
15749 : #endif
15750 :
15751 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15752 :
15753 : #if CK5_ENABLED
15754 : PURE module subroutine setUnifRandRNGGLU_D1_CK5(rng, rand, lb, ub)
15755 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15756 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_CK5
15757 : #endif
15758 : use pm_kind, only: CKC => CK5
15759 : complex(CKC) , intent(out) :: rand(:)
15760 : complex(CKC) , intent(in) :: lb, ub
15761 : type(xoshiro256ssg_type) , intent(inout) :: rng
15762 : end subroutine
15763 : #endif
15764 :
15765 : #if CK4_ENABLED
15766 : PURE module subroutine setUnifRandRNGGLU_D1_CK4(rng, rand, lb, ub)
15767 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15768 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_CK4
15769 : #endif
15770 : use pm_kind, only: CKC => CK4
15771 : complex(CKC) , intent(out) :: rand(:)
15772 : complex(CKC) , intent(in) :: lb, ub
15773 : type(xoshiro256ssg_type) , intent(inout) :: rng
15774 : end subroutine
15775 : #endif
15776 :
15777 : #if CK3_ENABLED
15778 : PURE module subroutine setUnifRandRNGGLU_D1_CK3(rng, rand, lb, ub)
15779 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15780 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_CK3
15781 : #endif
15782 : use pm_kind, only: CKC => CK3
15783 : complex(CKC) , intent(out) :: rand(:)
15784 : complex(CKC) , intent(in) :: lb, ub
15785 : type(xoshiro256ssg_type) , intent(inout) :: rng
15786 : end subroutine
15787 : #endif
15788 :
15789 : #if CK2_ENABLED
15790 : PURE module subroutine setUnifRandRNGGLU_D1_CK2(rng, rand, lb, ub)
15791 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15792 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_CK2
15793 : #endif
15794 : use pm_kind, only: CKC => CK2
15795 : complex(CKC) , intent(out) :: rand(:)
15796 : complex(CKC) , intent(in) :: lb, ub
15797 : type(xoshiro256ssg_type) , intent(inout) :: rng
15798 : end subroutine
15799 : #endif
15800 :
15801 : #if CK1_ENABLED
15802 : PURE module subroutine setUnifRandRNGGLU_D1_CK1(rng, rand, lb, ub)
15803 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15804 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_CK1
15805 : #endif
15806 : use pm_kind, only: CKC => CK1
15807 : complex(CKC) , intent(out) :: rand(:)
15808 : complex(CKC) , intent(in) :: lb, ub
15809 : type(xoshiro256ssg_type) , intent(inout) :: rng
15810 : end subroutine
15811 : #endif
15812 :
15813 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15814 :
15815 : #if RK5_ENABLED
15816 : PURE module subroutine setUnifRandRNGGLU_D1_RK5(rng, rand, lb, ub)
15817 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15818 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_RK5
15819 : #endif
15820 : use pm_kind, only: RKC => RK5
15821 : real(RKC) , intent(out) :: rand(:)
15822 : real(RKC) , intent(in) :: lb, ub
15823 : type(xoshiro256ssg_type) , intent(inout) :: rng
15824 : end subroutine
15825 : #endif
15826 :
15827 : #if RK4_ENABLED
15828 : PURE module subroutine setUnifRandRNGGLU_D1_RK4(rng, rand, lb, ub)
15829 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15830 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_RK4
15831 : #endif
15832 : use pm_kind, only: RKC => RK4
15833 : real(RKC) , intent(out) :: rand(:)
15834 : real(RKC) , intent(in) :: lb, ub
15835 : type(xoshiro256ssg_type) , intent(inout) :: rng
15836 : end subroutine
15837 : #endif
15838 :
15839 : #if RK3_ENABLED
15840 : PURE module subroutine setUnifRandRNGGLU_D1_RK3(rng, rand, lb, ub)
15841 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15842 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_RK3
15843 : #endif
15844 : use pm_kind, only: RKC => RK3
15845 : real(RKC) , intent(out) :: rand(:)
15846 : real(RKC) , intent(in) :: lb, ub
15847 : type(xoshiro256ssg_type) , intent(inout) :: rng
15848 : end subroutine
15849 : #endif
15850 :
15851 : #if RK2_ENABLED
15852 : PURE module subroutine setUnifRandRNGGLU_D1_RK2(rng, rand, lb, ub)
15853 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15854 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_RK2
15855 : #endif
15856 : use pm_kind, only: RKC => RK2
15857 : real(RKC) , intent(out) :: rand(:)
15858 : real(RKC) , intent(in) :: lb, ub
15859 : type(xoshiro256ssg_type) , intent(inout) :: rng
15860 : end subroutine
15861 : #endif
15862 :
15863 : #if RK1_ENABLED
15864 : PURE module subroutine setUnifRandRNGGLU_D1_RK1(rng, rand, lb, ub)
15865 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15866 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D1_RK1
15867 : #endif
15868 : use pm_kind, only: RKC => RK1
15869 : real(RKC) , intent(out) :: rand(:)
15870 : real(RKC) , intent(in) :: lb, ub
15871 : type(xoshiro256ssg_type) , intent(inout) :: rng
15872 : end subroutine
15873 : #endif
15874 :
15875 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15876 :
15877 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15878 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15879 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15880 :
15881 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15882 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15883 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15884 :
15885 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15886 :
15887 : #if SK5_ENABLED
15888 : PURE module subroutine setUnifRandRNGGDD_D2_SK5(rng, rand)
15889 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15890 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_SK5
15891 : #endif
15892 : use pm_kind, only: SKC => SK5
15893 : character(*,SKC) , intent(out) :: rand(:,:)
15894 : type(xoshiro256ssg_type) , intent(inout) :: rng
15895 : end subroutine
15896 : #endif
15897 :
15898 : #if SK4_ENABLED
15899 : PURE module subroutine setUnifRandRNGGDD_D2_SK4(rng, rand)
15900 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15901 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_SK4
15902 : #endif
15903 : use pm_kind, only: SKC => SK4
15904 : character(*,SKC) , intent(out) :: rand(:,:)
15905 : type(xoshiro256ssg_type) , intent(inout) :: rng
15906 : end subroutine
15907 : #endif
15908 :
15909 : #if SK3_ENABLED
15910 : PURE module subroutine setUnifRandRNGGDD_D2_SK3(rng, rand)
15911 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15912 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_SK3
15913 : #endif
15914 : use pm_kind, only: SKC => SK3
15915 : character(*,SKC) , intent(out) :: rand(:,:)
15916 : type(xoshiro256ssg_type) , intent(inout) :: rng
15917 : end subroutine
15918 : #endif
15919 :
15920 : #if SK2_ENABLED
15921 : PURE module subroutine setUnifRandRNGGDD_D2_SK2(rng, rand)
15922 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15923 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_SK2
15924 : #endif
15925 : use pm_kind, only: SKC => SK2
15926 : character(*,SKC) , intent(out) :: rand(:,:)
15927 : type(xoshiro256ssg_type) , intent(inout) :: rng
15928 : end subroutine
15929 : #endif
15930 :
15931 : #if SK1_ENABLED
15932 : PURE module subroutine setUnifRandRNGGDD_D2_SK1(rng, rand)
15933 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15934 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_SK1
15935 : #endif
15936 : use pm_kind, only: SKC => SK1
15937 : character(*,SKC) , intent(out) :: rand(:,:)
15938 : type(xoshiro256ssg_type) , intent(inout) :: rng
15939 : end subroutine
15940 : #endif
15941 :
15942 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
15943 :
15944 : #if IK5_ENABLED
15945 : PURE module subroutine setUnifRandRNGGDD_D2_IK5(rng, rand)
15946 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15947 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_IK5
15948 : #endif
15949 : use pm_kind, only: IKC => IK5
15950 : integer(IKC) , intent(out) :: rand(:,:)
15951 : type(xoshiro256ssg_type) , intent(inout) :: rng
15952 : end subroutine
15953 : #endif
15954 :
15955 : #if IK4_ENABLED
15956 : PURE module subroutine setUnifRandRNGGDD_D2_IK4(rng, rand)
15957 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15958 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_IK4
15959 : #endif
15960 : use pm_kind, only: IKC => IK4
15961 : integer(IKC) , intent(out) :: rand(:,:)
15962 : type(xoshiro256ssg_type) , intent(inout) :: rng
15963 : end subroutine
15964 : #endif
15965 :
15966 : #if IK3_ENABLED
15967 : PURE module subroutine setUnifRandRNGGDD_D2_IK3(rng, rand)
15968 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15969 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_IK3
15970 : #endif
15971 : use pm_kind, only: IKC => IK3
15972 : integer(IKC) , intent(out) :: rand(:,:)
15973 : type(xoshiro256ssg_type) , intent(inout) :: rng
15974 : end subroutine
15975 : #endif
15976 :
15977 : #if IK2_ENABLED
15978 : PURE module subroutine setUnifRandRNGGDD_D2_IK2(rng, rand)
15979 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15980 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_IK2
15981 : #endif
15982 : use pm_kind, only: IKC => IK2
15983 : integer(IKC) , intent(out) :: rand(:,:)
15984 : type(xoshiro256ssg_type) , intent(inout) :: rng
15985 : end subroutine
15986 : #endif
15987 :
15988 : #if IK1_ENABLED
15989 : PURE module subroutine setUnifRandRNGGDD_D2_IK1(rng, rand)
15990 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
15991 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_IK1
15992 : #endif
15993 : use pm_kind, only: IKC => IK1
15994 : integer(IKC) , intent(out) :: rand(:,:)
15995 : type(xoshiro256ssg_type) , intent(inout) :: rng
15996 : end subroutine
15997 : #endif
15998 :
15999 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16000 :
16001 : #if LK5_ENABLED
16002 : PURE module subroutine setUnifRandRNGGDD_D2_LK5(rng, rand)
16003 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16004 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_LK5
16005 : #endif
16006 : use pm_kind, only: LKC => LK5
16007 : logical(LKC) , intent(out) :: rand(:,:)
16008 : type(xoshiro256ssg_type) , intent(inout) :: rng
16009 : end subroutine
16010 : #endif
16011 :
16012 : #if LK4_ENABLED
16013 : PURE module subroutine setUnifRandRNGGDD_D2_LK4(rng, rand)
16014 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16015 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_LK4
16016 : #endif
16017 : use pm_kind, only: LKC => LK4
16018 : logical(LKC) , intent(out) :: rand(:,:)
16019 : type(xoshiro256ssg_type) , intent(inout) :: rng
16020 : end subroutine
16021 : #endif
16022 :
16023 : #if LK3_ENABLED
16024 : PURE module subroutine setUnifRandRNGGDD_D2_LK3(rng, rand)
16025 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16026 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_LK3
16027 : #endif
16028 : use pm_kind, only: LKC => LK3
16029 : logical(LKC) , intent(out) :: rand(:,:)
16030 : type(xoshiro256ssg_type) , intent(inout) :: rng
16031 : end subroutine
16032 : #endif
16033 :
16034 : #if LK2_ENABLED
16035 : PURE module subroutine setUnifRandRNGGDD_D2_LK2(rng, rand)
16036 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16037 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_LK2
16038 : #endif
16039 : use pm_kind, only: LKC => LK2
16040 : logical(LKC) , intent(out) :: rand(:,:)
16041 : type(xoshiro256ssg_type) , intent(inout) :: rng
16042 : end subroutine
16043 : #endif
16044 :
16045 : #if LK1_ENABLED
16046 : PURE module subroutine setUnifRandRNGGDD_D2_LK1(rng, rand)
16047 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16048 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_LK1
16049 : #endif
16050 : use pm_kind, only: LKC => LK1
16051 : logical(LKC) , intent(out) :: rand(:,:)
16052 : type(xoshiro256ssg_type) , intent(inout) :: rng
16053 : end subroutine
16054 : #endif
16055 :
16056 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16057 :
16058 : #if CK5_ENABLED
16059 : PURE module subroutine setUnifRandRNGGDD_D2_CK5(rng, rand)
16060 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16061 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_CK5
16062 : #endif
16063 : use pm_kind, only: CKC => CK5
16064 : complex(CKC) , intent(out) :: rand(:,:)
16065 : type(xoshiro256ssg_type) , intent(inout) :: rng
16066 : end subroutine
16067 : #endif
16068 :
16069 : #if CK4_ENABLED
16070 : PURE module subroutine setUnifRandRNGGDD_D2_CK4(rng, rand)
16071 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16072 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_CK4
16073 : #endif
16074 : use pm_kind, only: CKC => CK4
16075 : complex(CKC) , intent(out) :: rand(:,:)
16076 : type(xoshiro256ssg_type) , intent(inout) :: rng
16077 : end subroutine
16078 : #endif
16079 :
16080 : #if CK3_ENABLED
16081 : PURE module subroutine setUnifRandRNGGDD_D2_CK3(rng, rand)
16082 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16083 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_CK3
16084 : #endif
16085 : use pm_kind, only: CKC => CK3
16086 : complex(CKC) , intent(out) :: rand(:,:)
16087 : type(xoshiro256ssg_type) , intent(inout) :: rng
16088 : end subroutine
16089 : #endif
16090 :
16091 : #if CK2_ENABLED
16092 : PURE module subroutine setUnifRandRNGGDD_D2_CK2(rng, rand)
16093 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16094 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_CK2
16095 : #endif
16096 : use pm_kind, only: CKC => CK2
16097 : complex(CKC) , intent(out) :: rand(:,:)
16098 : type(xoshiro256ssg_type) , intent(inout) :: rng
16099 : end subroutine
16100 : #endif
16101 :
16102 : #if CK1_ENABLED
16103 : PURE module subroutine setUnifRandRNGGDD_D2_CK1(rng, rand)
16104 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16105 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_CK1
16106 : #endif
16107 : use pm_kind, only: CKC => CK1
16108 : complex(CKC) , intent(out) :: rand(:,:)
16109 : type(xoshiro256ssg_type) , intent(inout) :: rng
16110 : end subroutine
16111 : #endif
16112 :
16113 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16114 :
16115 : #if RK5_ENABLED
16116 : PURE module subroutine setUnifRandRNGGDD_D2_RK5(rng, rand)
16117 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16118 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_RK5
16119 : #endif
16120 : use pm_kind, only: RKC => RK5
16121 : real(RKC) , intent(out) :: rand(:,:)
16122 : type(xoshiro256ssg_type) , intent(inout) :: rng
16123 : end subroutine
16124 : #endif
16125 :
16126 : #if RK4_ENABLED
16127 : PURE module subroutine setUnifRandRNGGDD_D2_RK4(rng, rand)
16128 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16129 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_RK4
16130 : #endif
16131 : use pm_kind, only: RKC => RK4
16132 : real(RKC) , intent(out) :: rand(:,:)
16133 : type(xoshiro256ssg_type) , intent(inout) :: rng
16134 : end subroutine
16135 : #endif
16136 :
16137 : #if RK3_ENABLED
16138 : PURE module subroutine setUnifRandRNGGDD_D2_RK3(rng, rand)
16139 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16140 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_RK3
16141 : #endif
16142 : use pm_kind, only: RKC => RK3
16143 : real(RKC) , intent(out) :: rand(:,:)
16144 : type(xoshiro256ssg_type) , intent(inout) :: rng
16145 : end subroutine
16146 : #endif
16147 :
16148 : #if RK2_ENABLED
16149 : PURE module subroutine setUnifRandRNGGDD_D2_RK2(rng, rand)
16150 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16151 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_RK2
16152 : #endif
16153 : use pm_kind, only: RKC => RK2
16154 : real(RKC) , intent(out) :: rand(:,:)
16155 : type(xoshiro256ssg_type) , intent(inout) :: rng
16156 : end subroutine
16157 : #endif
16158 :
16159 : #if RK1_ENABLED
16160 : PURE module subroutine setUnifRandRNGGDD_D2_RK1(rng, rand)
16161 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16162 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D2_RK1
16163 : #endif
16164 : use pm_kind, only: RKC => RK1
16165 : real(RKC) , intent(out) :: rand(:,:)
16166 : type(xoshiro256ssg_type) , intent(inout) :: rng
16167 : end subroutine
16168 : #endif
16169 :
16170 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16171 :
16172 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16173 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16174 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16175 :
16176 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16177 :
16178 : #if SK5_ENABLED
16179 : PURE module subroutine setUnifRandRNGGLU_D2_SK5(rng, rand, lb, ub)
16180 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16181 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_SK5
16182 : #endif
16183 : use pm_kind, only: SKC => SK5
16184 : character(*,SKC) , intent(out) :: rand(:,:)
16185 : character(*,SKC) , intent(in) :: lb, ub
16186 : type(xoshiro256ssg_type) , intent(inout) :: rng
16187 : end subroutine
16188 : #endif
16189 :
16190 : #if SK4_ENABLED
16191 : PURE module subroutine setUnifRandRNGGLU_D2_SK4(rng, rand, lb, ub)
16192 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16193 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_SK4
16194 : #endif
16195 : use pm_kind, only: SKC => SK4
16196 : character(*,SKC) , intent(out) :: rand(:,:)
16197 : character(*,SKC) , intent(in) :: lb, ub
16198 : type(xoshiro256ssg_type) , intent(inout) :: rng
16199 : end subroutine
16200 : #endif
16201 :
16202 : #if SK3_ENABLED
16203 : PURE module subroutine setUnifRandRNGGLU_D2_SK3(rng, rand, lb, ub)
16204 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16205 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_SK3
16206 : #endif
16207 : use pm_kind, only: SKC => SK3
16208 : character(*,SKC) , intent(out) :: rand(:,:)
16209 : character(*,SKC) , intent(in) :: lb, ub
16210 : type(xoshiro256ssg_type) , intent(inout) :: rng
16211 : end subroutine
16212 : #endif
16213 :
16214 : #if SK2_ENABLED
16215 : PURE module subroutine setUnifRandRNGGLU_D2_SK2(rng, rand, lb, ub)
16216 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16217 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_SK2
16218 : #endif
16219 : use pm_kind, only: SKC => SK2
16220 : character(*,SKC) , intent(out) :: rand(:,:)
16221 : character(*,SKC) , intent(in) :: lb, ub
16222 : type(xoshiro256ssg_type) , intent(inout) :: rng
16223 : end subroutine
16224 : #endif
16225 :
16226 : #if SK1_ENABLED
16227 : PURE module subroutine setUnifRandRNGGLU_D2_SK1(rng, rand, lb, ub)
16228 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16229 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_SK1
16230 : #endif
16231 : use pm_kind, only: SKC => SK1
16232 : character(*,SKC) , intent(out) :: rand(:,:)
16233 : character(*,SKC) , intent(in) :: lb, ub
16234 : type(xoshiro256ssg_type) , intent(inout) :: rng
16235 : end subroutine
16236 : #endif
16237 :
16238 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16239 :
16240 : #if IK5_ENABLED
16241 : PURE module subroutine setUnifRandRNGGLU_D2_IK5(rng, rand, lb, ub)
16242 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16243 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_IK5
16244 : #endif
16245 : use pm_kind, only: IKC => IK5
16246 : integer(IKC) , intent(out) :: rand(:,:)
16247 : integer(IKC) , intent(in) :: lb, ub
16248 : type(xoshiro256ssg_type) , intent(inout) :: rng
16249 : end subroutine
16250 : #endif
16251 :
16252 : #if IK4_ENABLED
16253 : PURE module subroutine setUnifRandRNGGLU_D2_IK4(rng, rand, lb, ub)
16254 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16255 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_IK4
16256 : #endif
16257 : use pm_kind, only: IKC => IK4
16258 : integer(IKC) , intent(out) :: rand(:,:)
16259 : integer(IKC) , intent(in) :: lb, ub
16260 : type(xoshiro256ssg_type) , intent(inout) :: rng
16261 : end subroutine
16262 : #endif
16263 :
16264 : #if IK3_ENABLED
16265 : PURE module subroutine setUnifRandRNGGLU_D2_IK3(rng, rand, lb, ub)
16266 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16267 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_IK3
16268 : #endif
16269 : use pm_kind, only: IKC => IK3
16270 : integer(IKC) , intent(out) :: rand(:,:)
16271 : integer(IKC) , intent(in) :: lb, ub
16272 : type(xoshiro256ssg_type) , intent(inout) :: rng
16273 : end subroutine
16274 : #endif
16275 :
16276 : #if IK2_ENABLED
16277 : PURE module subroutine setUnifRandRNGGLU_D2_IK2(rng, rand, lb, ub)
16278 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16279 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_IK2
16280 : #endif
16281 : use pm_kind, only: IKC => IK2
16282 : integer(IKC) , intent(out) :: rand(:,:)
16283 : integer(IKC) , intent(in) :: lb, ub
16284 : type(xoshiro256ssg_type) , intent(inout) :: rng
16285 : end subroutine
16286 : #endif
16287 :
16288 : #if IK1_ENABLED
16289 : PURE module subroutine setUnifRandRNGGLU_D2_IK1(rng, rand, lb, ub)
16290 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16291 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_IK1
16292 : #endif
16293 : use pm_kind, only: IKC => IK1
16294 : integer(IKC) , intent(out) :: rand(:,:)
16295 : integer(IKC) , intent(in) :: lb, ub
16296 : type(xoshiro256ssg_type) , intent(inout) :: rng
16297 : end subroutine
16298 : #endif
16299 :
16300 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16301 :
16302 : #if LK5_ENABLED
16303 : PURE module subroutine setUnifRandRNGGLU_D2_LK5(rng, rand, lb, ub)
16304 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16305 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_LK5
16306 : #endif
16307 : use pm_kind, only: LKC => LK5
16308 : logical(LKC) , intent(out) :: rand(:,:)
16309 : logical(LKC) , intent(in) :: lb, ub
16310 : type(xoshiro256ssg_type) , intent(inout) :: rng
16311 : end subroutine
16312 : #endif
16313 :
16314 : #if LK4_ENABLED
16315 : PURE module subroutine setUnifRandRNGGLU_D2_LK4(rng, rand, lb, ub)
16316 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16317 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_LK4
16318 : #endif
16319 : use pm_kind, only: LKC => LK4
16320 : logical(LKC) , intent(out) :: rand(:,:)
16321 : logical(LKC) , intent(in) :: lb, ub
16322 : type(xoshiro256ssg_type) , intent(inout) :: rng
16323 : end subroutine
16324 : #endif
16325 :
16326 : #if LK3_ENABLED
16327 : PURE module subroutine setUnifRandRNGGLU_D2_LK3(rng, rand, lb, ub)
16328 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16329 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_LK3
16330 : #endif
16331 : use pm_kind, only: LKC => LK3
16332 : logical(LKC) , intent(out) :: rand(:,:)
16333 : logical(LKC) , intent(in) :: lb, ub
16334 : type(xoshiro256ssg_type) , intent(inout) :: rng
16335 : end subroutine
16336 : #endif
16337 :
16338 : #if LK2_ENABLED
16339 : PURE module subroutine setUnifRandRNGGLU_D2_LK2(rng, rand, lb, ub)
16340 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16341 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_LK2
16342 : #endif
16343 : use pm_kind, only: LKC => LK2
16344 : logical(LKC) , intent(out) :: rand(:,:)
16345 : logical(LKC) , intent(in) :: lb, ub
16346 : type(xoshiro256ssg_type) , intent(inout) :: rng
16347 : end subroutine
16348 : #endif
16349 :
16350 : #if LK1_ENABLED
16351 : PURE module subroutine setUnifRandRNGGLU_D2_LK1(rng, rand, lb, ub)
16352 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16353 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_LK1
16354 : #endif
16355 : use pm_kind, only: LKC => LK1
16356 : logical(LKC) , intent(out) :: rand(:,:)
16357 : logical(LKC) , intent(in) :: lb, ub
16358 : type(xoshiro256ssg_type) , intent(inout) :: rng
16359 : end subroutine
16360 : #endif
16361 :
16362 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16363 :
16364 : #if CK5_ENABLED
16365 : PURE module subroutine setUnifRandRNGGLU_D2_CK5(rng, rand, lb, ub)
16366 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16367 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_CK5
16368 : #endif
16369 : use pm_kind, only: CKC => CK5
16370 : complex(CKC) , intent(out) :: rand(:,:)
16371 : complex(CKC) , intent(in) :: lb, ub
16372 : type(xoshiro256ssg_type) , intent(inout) :: rng
16373 : end subroutine
16374 : #endif
16375 :
16376 : #if CK4_ENABLED
16377 : PURE module subroutine setUnifRandRNGGLU_D2_CK4(rng, rand, lb, ub)
16378 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16379 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_CK4
16380 : #endif
16381 : use pm_kind, only: CKC => CK4
16382 : complex(CKC) , intent(out) :: rand(:,:)
16383 : complex(CKC) , intent(in) :: lb, ub
16384 : type(xoshiro256ssg_type) , intent(inout) :: rng
16385 : end subroutine
16386 : #endif
16387 :
16388 : #if CK3_ENABLED
16389 : PURE module subroutine setUnifRandRNGGLU_D2_CK3(rng, rand, lb, ub)
16390 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16391 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_CK3
16392 : #endif
16393 : use pm_kind, only: CKC => CK3
16394 : complex(CKC) , intent(out) :: rand(:,:)
16395 : complex(CKC) , intent(in) :: lb, ub
16396 : type(xoshiro256ssg_type) , intent(inout) :: rng
16397 : end subroutine
16398 : #endif
16399 :
16400 : #if CK2_ENABLED
16401 : PURE module subroutine setUnifRandRNGGLU_D2_CK2(rng, rand, lb, ub)
16402 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16403 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_CK2
16404 : #endif
16405 : use pm_kind, only: CKC => CK2
16406 : complex(CKC) , intent(out) :: rand(:,:)
16407 : complex(CKC) , intent(in) :: lb, ub
16408 : type(xoshiro256ssg_type) , intent(inout) :: rng
16409 : end subroutine
16410 : #endif
16411 :
16412 : #if CK1_ENABLED
16413 : PURE module subroutine setUnifRandRNGGLU_D2_CK1(rng, rand, lb, ub)
16414 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16415 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_CK1
16416 : #endif
16417 : use pm_kind, only: CKC => CK1
16418 : complex(CKC) , intent(out) :: rand(:,:)
16419 : complex(CKC) , intent(in) :: lb, ub
16420 : type(xoshiro256ssg_type) , intent(inout) :: rng
16421 : end subroutine
16422 : #endif
16423 :
16424 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16425 :
16426 : #if RK5_ENABLED
16427 : PURE module subroutine setUnifRandRNGGLU_D2_RK5(rng, rand, lb, ub)
16428 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16429 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_RK5
16430 : #endif
16431 : use pm_kind, only: RKC => RK5
16432 : real(RKC) , intent(out) :: rand(:,:)
16433 : real(RKC) , intent(in) :: lb, ub
16434 : type(xoshiro256ssg_type) , intent(inout) :: rng
16435 : end subroutine
16436 : #endif
16437 :
16438 : #if RK4_ENABLED
16439 : PURE module subroutine setUnifRandRNGGLU_D2_RK4(rng, rand, lb, ub)
16440 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16441 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_RK4
16442 : #endif
16443 : use pm_kind, only: RKC => RK4
16444 : real(RKC) , intent(out) :: rand(:,:)
16445 : real(RKC) , intent(in) :: lb, ub
16446 : type(xoshiro256ssg_type) , intent(inout) :: rng
16447 : end subroutine
16448 : #endif
16449 :
16450 : #if RK3_ENABLED
16451 : PURE module subroutine setUnifRandRNGGLU_D2_RK3(rng, rand, lb, ub)
16452 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16453 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_RK3
16454 : #endif
16455 : use pm_kind, only: RKC => RK3
16456 : real(RKC) , intent(out) :: rand(:,:)
16457 : real(RKC) , intent(in) :: lb, ub
16458 : type(xoshiro256ssg_type) , intent(inout) :: rng
16459 : end subroutine
16460 : #endif
16461 :
16462 : #if RK2_ENABLED
16463 : PURE module subroutine setUnifRandRNGGLU_D2_RK2(rng, rand, lb, ub)
16464 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16465 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_RK2
16466 : #endif
16467 : use pm_kind, only: RKC => RK2
16468 : real(RKC) , intent(out) :: rand(:,:)
16469 : real(RKC) , intent(in) :: lb, ub
16470 : type(xoshiro256ssg_type) , intent(inout) :: rng
16471 : end subroutine
16472 : #endif
16473 :
16474 : #if RK1_ENABLED
16475 : PURE module subroutine setUnifRandRNGGLU_D2_RK1(rng, rand, lb, ub)
16476 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16477 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D2_RK1
16478 : #endif
16479 : use pm_kind, only: RKC => RK1
16480 : real(RKC) , intent(out) :: rand(:,:)
16481 : real(RKC) , intent(in) :: lb, ub
16482 : type(xoshiro256ssg_type) , intent(inout) :: rng
16483 : end subroutine
16484 : #endif
16485 :
16486 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16487 :
16488 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16489 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16490 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16491 :
16492 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16493 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16494 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16495 :
16496 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16497 :
16498 : #if SK5_ENABLED
16499 : PURE module subroutine setUnifRandRNGGDD_D3_SK5(rng, rand)
16500 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16501 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_SK5
16502 : #endif
16503 : use pm_kind, only: SKC => SK5
16504 : character(*,SKC) , intent(out) :: rand(:,:,:)
16505 : type(xoshiro256ssg_type) , intent(inout) :: rng
16506 : end subroutine
16507 : #endif
16508 :
16509 : #if SK4_ENABLED
16510 : PURE module subroutine setUnifRandRNGGDD_D3_SK4(rng, rand)
16511 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16512 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_SK4
16513 : #endif
16514 : use pm_kind, only: SKC => SK4
16515 : character(*,SKC) , intent(out) :: rand(:,:,:)
16516 : type(xoshiro256ssg_type) , intent(inout) :: rng
16517 : end subroutine
16518 : #endif
16519 :
16520 : #if SK3_ENABLED
16521 : PURE module subroutine setUnifRandRNGGDD_D3_SK3(rng, rand)
16522 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16523 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_SK3
16524 : #endif
16525 : use pm_kind, only: SKC => SK3
16526 : character(*,SKC) , intent(out) :: rand(:,:,:)
16527 : type(xoshiro256ssg_type) , intent(inout) :: rng
16528 : end subroutine
16529 : #endif
16530 :
16531 : #if SK2_ENABLED
16532 : PURE module subroutine setUnifRandRNGGDD_D3_SK2(rng, rand)
16533 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16534 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_SK2
16535 : #endif
16536 : use pm_kind, only: SKC => SK2
16537 : character(*,SKC) , intent(out) :: rand(:,:,:)
16538 : type(xoshiro256ssg_type) , intent(inout) :: rng
16539 : end subroutine
16540 : #endif
16541 :
16542 : #if SK1_ENABLED
16543 : PURE module subroutine setUnifRandRNGGDD_D3_SK1(rng, rand)
16544 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16545 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_SK1
16546 : #endif
16547 : use pm_kind, only: SKC => SK1
16548 : character(*,SKC) , intent(out) :: rand(:,:,:)
16549 : type(xoshiro256ssg_type) , intent(inout) :: rng
16550 : end subroutine
16551 : #endif
16552 :
16553 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16554 :
16555 : #if IK5_ENABLED
16556 : PURE module subroutine setUnifRandRNGGDD_D3_IK5(rng, rand)
16557 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16558 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_IK5
16559 : #endif
16560 : use pm_kind, only: IKC => IK5
16561 : integer(IKC) , intent(out) :: rand(:,:,:)
16562 : type(xoshiro256ssg_type) , intent(inout) :: rng
16563 : end subroutine
16564 : #endif
16565 :
16566 : #if IK4_ENABLED
16567 : PURE module subroutine setUnifRandRNGGDD_D3_IK4(rng, rand)
16568 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16569 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_IK4
16570 : #endif
16571 : use pm_kind, only: IKC => IK4
16572 : integer(IKC) , intent(out) :: rand(:,:,:)
16573 : type(xoshiro256ssg_type) , intent(inout) :: rng
16574 : end subroutine
16575 : #endif
16576 :
16577 : #if IK3_ENABLED
16578 : PURE module subroutine setUnifRandRNGGDD_D3_IK3(rng, rand)
16579 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16580 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_IK3
16581 : #endif
16582 : use pm_kind, only: IKC => IK3
16583 : integer(IKC) , intent(out) :: rand(:,:,:)
16584 : type(xoshiro256ssg_type) , intent(inout) :: rng
16585 : end subroutine
16586 : #endif
16587 :
16588 : #if IK2_ENABLED
16589 : PURE module subroutine setUnifRandRNGGDD_D3_IK2(rng, rand)
16590 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16591 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_IK2
16592 : #endif
16593 : use pm_kind, only: IKC => IK2
16594 : integer(IKC) , intent(out) :: rand(:,:,:)
16595 : type(xoshiro256ssg_type) , intent(inout) :: rng
16596 : end subroutine
16597 : #endif
16598 :
16599 : #if IK1_ENABLED
16600 : PURE module subroutine setUnifRandRNGGDD_D3_IK1(rng, rand)
16601 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16602 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_IK1
16603 : #endif
16604 : use pm_kind, only: IKC => IK1
16605 : integer(IKC) , intent(out) :: rand(:,:,:)
16606 : type(xoshiro256ssg_type) , intent(inout) :: rng
16607 : end subroutine
16608 : #endif
16609 :
16610 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16611 :
16612 : #if LK5_ENABLED
16613 : PURE module subroutine setUnifRandRNGGDD_D3_LK5(rng, rand)
16614 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16615 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_LK5
16616 : #endif
16617 : use pm_kind, only: LKC => LK5
16618 : logical(LKC) , intent(out) :: rand(:,:,:)
16619 : type(xoshiro256ssg_type) , intent(inout) :: rng
16620 : end subroutine
16621 : #endif
16622 :
16623 : #if LK4_ENABLED
16624 : PURE module subroutine setUnifRandRNGGDD_D3_LK4(rng, rand)
16625 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16626 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_LK4
16627 : #endif
16628 : use pm_kind, only: LKC => LK4
16629 : logical(LKC) , intent(out) :: rand(:,:,:)
16630 : type(xoshiro256ssg_type) , intent(inout) :: rng
16631 : end subroutine
16632 : #endif
16633 :
16634 : #if LK3_ENABLED
16635 : PURE module subroutine setUnifRandRNGGDD_D3_LK3(rng, rand)
16636 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16637 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_LK3
16638 : #endif
16639 : use pm_kind, only: LKC => LK3
16640 : logical(LKC) , intent(out) :: rand(:,:,:)
16641 : type(xoshiro256ssg_type) , intent(inout) :: rng
16642 : end subroutine
16643 : #endif
16644 :
16645 : #if LK2_ENABLED
16646 : PURE module subroutine setUnifRandRNGGDD_D3_LK2(rng, rand)
16647 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16648 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_LK2
16649 : #endif
16650 : use pm_kind, only: LKC => LK2
16651 : logical(LKC) , intent(out) :: rand(:,:,:)
16652 : type(xoshiro256ssg_type) , intent(inout) :: rng
16653 : end subroutine
16654 : #endif
16655 :
16656 : #if LK1_ENABLED
16657 : PURE module subroutine setUnifRandRNGGDD_D3_LK1(rng, rand)
16658 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16659 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_LK1
16660 : #endif
16661 : use pm_kind, only: LKC => LK1
16662 : logical(LKC) , intent(out) :: rand(:,:,:)
16663 : type(xoshiro256ssg_type) , intent(inout) :: rng
16664 : end subroutine
16665 : #endif
16666 :
16667 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16668 :
16669 : #if CK5_ENABLED
16670 : PURE module subroutine setUnifRandRNGGDD_D3_CK5(rng, rand)
16671 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16672 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_CK5
16673 : #endif
16674 : use pm_kind, only: CKC => CK5
16675 : complex(CKC) , intent(out) :: rand(:,:,:)
16676 : type(xoshiro256ssg_type) , intent(inout) :: rng
16677 : end subroutine
16678 : #endif
16679 :
16680 : #if CK4_ENABLED
16681 : PURE module subroutine setUnifRandRNGGDD_D3_CK4(rng, rand)
16682 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16683 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_CK4
16684 : #endif
16685 : use pm_kind, only: CKC => CK4
16686 : complex(CKC) , intent(out) :: rand(:,:,:)
16687 : type(xoshiro256ssg_type) , intent(inout) :: rng
16688 : end subroutine
16689 : #endif
16690 :
16691 : #if CK3_ENABLED
16692 : PURE module subroutine setUnifRandRNGGDD_D3_CK3(rng, rand)
16693 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16694 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_CK3
16695 : #endif
16696 : use pm_kind, only: CKC => CK3
16697 : complex(CKC) , intent(out) :: rand(:,:,:)
16698 : type(xoshiro256ssg_type) , intent(inout) :: rng
16699 : end subroutine
16700 : #endif
16701 :
16702 : #if CK2_ENABLED
16703 : PURE module subroutine setUnifRandRNGGDD_D3_CK2(rng, rand)
16704 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16705 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_CK2
16706 : #endif
16707 : use pm_kind, only: CKC => CK2
16708 : complex(CKC) , intent(out) :: rand(:,:,:)
16709 : type(xoshiro256ssg_type) , intent(inout) :: rng
16710 : end subroutine
16711 : #endif
16712 :
16713 : #if CK1_ENABLED
16714 : PURE module subroutine setUnifRandRNGGDD_D3_CK1(rng, rand)
16715 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16716 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_CK1
16717 : #endif
16718 : use pm_kind, only: CKC => CK1
16719 : complex(CKC) , intent(out) :: rand(:,:,:)
16720 : type(xoshiro256ssg_type) , intent(inout) :: rng
16721 : end subroutine
16722 : #endif
16723 :
16724 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16725 :
16726 : #if RK5_ENABLED
16727 : PURE module subroutine setUnifRandRNGGDD_D3_RK5(rng, rand)
16728 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16729 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_RK5
16730 : #endif
16731 : use pm_kind, only: RKC => RK5
16732 : real(RKC) , intent(out) :: rand(:,:,:)
16733 : type(xoshiro256ssg_type) , intent(inout) :: rng
16734 : end subroutine
16735 : #endif
16736 :
16737 : #if RK4_ENABLED
16738 : PURE module subroutine setUnifRandRNGGDD_D3_RK4(rng, rand)
16739 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16740 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_RK4
16741 : #endif
16742 : use pm_kind, only: RKC => RK4
16743 : real(RKC) , intent(out) :: rand(:,:,:)
16744 : type(xoshiro256ssg_type) , intent(inout) :: rng
16745 : end subroutine
16746 : #endif
16747 :
16748 : #if RK3_ENABLED
16749 : PURE module subroutine setUnifRandRNGGDD_D3_RK3(rng, rand)
16750 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16751 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_RK3
16752 : #endif
16753 : use pm_kind, only: RKC => RK3
16754 : real(RKC) , intent(out) :: rand(:,:,:)
16755 : type(xoshiro256ssg_type) , intent(inout) :: rng
16756 : end subroutine
16757 : #endif
16758 :
16759 : #if RK2_ENABLED
16760 : PURE module subroutine setUnifRandRNGGDD_D3_RK2(rng, rand)
16761 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16762 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_RK2
16763 : #endif
16764 : use pm_kind, only: RKC => RK2
16765 : real(RKC) , intent(out) :: rand(:,:,:)
16766 : type(xoshiro256ssg_type) , intent(inout) :: rng
16767 : end subroutine
16768 : #endif
16769 :
16770 : #if RK1_ENABLED
16771 : PURE module subroutine setUnifRandRNGGDD_D3_RK1(rng, rand)
16772 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16773 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGDD_D3_RK1
16774 : #endif
16775 : use pm_kind, only: RKC => RK1
16776 : real(RKC) , intent(out) :: rand(:,:,:)
16777 : type(xoshiro256ssg_type) , intent(inout) :: rng
16778 : end subroutine
16779 : #endif
16780 :
16781 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16782 :
16783 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16784 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16785 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16786 :
16787 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16788 :
16789 : #if SK5_ENABLED
16790 : PURE module subroutine setUnifRandRNGGLU_D3_SK5(rng, rand, lb, ub)
16791 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16792 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_SK5
16793 : #endif
16794 : use pm_kind, only: SKC => SK5
16795 : character(*,SKC) , intent(out) :: rand(:,:,:)
16796 : character(*,SKC) , intent(in) :: lb, ub
16797 : type(xoshiro256ssg_type) , intent(inout) :: rng
16798 : end subroutine
16799 : #endif
16800 :
16801 : #if SK4_ENABLED
16802 : PURE module subroutine setUnifRandRNGGLU_D3_SK4(rng, rand, lb, ub)
16803 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16804 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_SK4
16805 : #endif
16806 : use pm_kind, only: SKC => SK4
16807 : character(*,SKC) , intent(out) :: rand(:,:,:)
16808 : character(*,SKC) , intent(in) :: lb, ub
16809 : type(xoshiro256ssg_type) , intent(inout) :: rng
16810 : end subroutine
16811 : #endif
16812 :
16813 : #if SK3_ENABLED
16814 : PURE module subroutine setUnifRandRNGGLU_D3_SK3(rng, rand, lb, ub)
16815 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16816 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_SK3
16817 : #endif
16818 : use pm_kind, only: SKC => SK3
16819 : character(*,SKC) , intent(out) :: rand(:,:,:)
16820 : character(*,SKC) , intent(in) :: lb, ub
16821 : type(xoshiro256ssg_type) , intent(inout) :: rng
16822 : end subroutine
16823 : #endif
16824 :
16825 : #if SK2_ENABLED
16826 : PURE module subroutine setUnifRandRNGGLU_D3_SK2(rng, rand, lb, ub)
16827 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16828 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_SK2
16829 : #endif
16830 : use pm_kind, only: SKC => SK2
16831 : character(*,SKC) , intent(out) :: rand(:,:,:)
16832 : character(*,SKC) , intent(in) :: lb, ub
16833 : type(xoshiro256ssg_type) , intent(inout) :: rng
16834 : end subroutine
16835 : #endif
16836 :
16837 : #if SK1_ENABLED
16838 : PURE module subroutine setUnifRandRNGGLU_D3_SK1(rng, rand, lb, ub)
16839 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16840 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_SK1
16841 : #endif
16842 : use pm_kind, only: SKC => SK1
16843 : character(*,SKC) , intent(out) :: rand(:,:,:)
16844 : character(*,SKC) , intent(in) :: lb, ub
16845 : type(xoshiro256ssg_type) , intent(inout) :: rng
16846 : end subroutine
16847 : #endif
16848 :
16849 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16850 :
16851 : #if IK5_ENABLED
16852 : PURE module subroutine setUnifRandRNGGLU_D3_IK5(rng, rand, lb, ub)
16853 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16854 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_IK5
16855 : #endif
16856 : use pm_kind, only: IKC => IK5
16857 : integer(IKC) , intent(out) :: rand(:,:,:)
16858 : integer(IKC) , intent(in) :: lb, ub
16859 : type(xoshiro256ssg_type) , intent(inout) :: rng
16860 : end subroutine
16861 : #endif
16862 :
16863 : #if IK4_ENABLED
16864 : PURE module subroutine setUnifRandRNGGLU_D3_IK4(rng, rand, lb, ub)
16865 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16866 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_IK4
16867 : #endif
16868 : use pm_kind, only: IKC => IK4
16869 : integer(IKC) , intent(out) :: rand(:,:,:)
16870 : integer(IKC) , intent(in) :: lb, ub
16871 : type(xoshiro256ssg_type) , intent(inout) :: rng
16872 : end subroutine
16873 : #endif
16874 :
16875 : #if IK3_ENABLED
16876 : PURE module subroutine setUnifRandRNGGLU_D3_IK3(rng, rand, lb, ub)
16877 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16878 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_IK3
16879 : #endif
16880 : use pm_kind, only: IKC => IK3
16881 : integer(IKC) , intent(out) :: rand(:,:,:)
16882 : integer(IKC) , intent(in) :: lb, ub
16883 : type(xoshiro256ssg_type) , intent(inout) :: rng
16884 : end subroutine
16885 : #endif
16886 :
16887 : #if IK2_ENABLED
16888 : PURE module subroutine setUnifRandRNGGLU_D3_IK2(rng, rand, lb, ub)
16889 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16890 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_IK2
16891 : #endif
16892 : use pm_kind, only: IKC => IK2
16893 : integer(IKC) , intent(out) :: rand(:,:,:)
16894 : integer(IKC) , intent(in) :: lb, ub
16895 : type(xoshiro256ssg_type) , intent(inout) :: rng
16896 : end subroutine
16897 : #endif
16898 :
16899 : #if IK1_ENABLED
16900 : PURE module subroutine setUnifRandRNGGLU_D3_IK1(rng, rand, lb, ub)
16901 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16902 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_IK1
16903 : #endif
16904 : use pm_kind, only: IKC => IK1
16905 : integer(IKC) , intent(out) :: rand(:,:,:)
16906 : integer(IKC) , intent(in) :: lb, ub
16907 : type(xoshiro256ssg_type) , intent(inout) :: rng
16908 : end subroutine
16909 : #endif
16910 :
16911 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16912 :
16913 : #if LK5_ENABLED
16914 : PURE module subroutine setUnifRandRNGGLU_D3_LK5(rng, rand, lb, ub)
16915 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16916 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_LK5
16917 : #endif
16918 : use pm_kind, only: LKC => LK5
16919 : logical(LKC) , intent(out) :: rand(:,:,:)
16920 : logical(LKC) , intent(in) :: lb, ub
16921 : type(xoshiro256ssg_type) , intent(inout) :: rng
16922 : end subroutine
16923 : #endif
16924 :
16925 : #if LK4_ENABLED
16926 : PURE module subroutine setUnifRandRNGGLU_D3_LK4(rng, rand, lb, ub)
16927 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16928 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_LK4
16929 : #endif
16930 : use pm_kind, only: LKC => LK4
16931 : logical(LKC) , intent(out) :: rand(:,:,:)
16932 : logical(LKC) , intent(in) :: lb, ub
16933 : type(xoshiro256ssg_type) , intent(inout) :: rng
16934 : end subroutine
16935 : #endif
16936 :
16937 : #if LK3_ENABLED
16938 : PURE module subroutine setUnifRandRNGGLU_D3_LK3(rng, rand, lb, ub)
16939 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16940 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_LK3
16941 : #endif
16942 : use pm_kind, only: LKC => LK3
16943 : logical(LKC) , intent(out) :: rand(:,:,:)
16944 : logical(LKC) , intent(in) :: lb, ub
16945 : type(xoshiro256ssg_type) , intent(inout) :: rng
16946 : end subroutine
16947 : #endif
16948 :
16949 : #if LK2_ENABLED
16950 : PURE module subroutine setUnifRandRNGGLU_D3_LK2(rng, rand, lb, ub)
16951 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16952 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_LK2
16953 : #endif
16954 : use pm_kind, only: LKC => LK2
16955 : logical(LKC) , intent(out) :: rand(:,:,:)
16956 : logical(LKC) , intent(in) :: lb, ub
16957 : type(xoshiro256ssg_type) , intent(inout) :: rng
16958 : end subroutine
16959 : #endif
16960 :
16961 : #if LK1_ENABLED
16962 : PURE module subroutine setUnifRandRNGGLU_D3_LK1(rng, rand, lb, ub)
16963 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16964 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_LK1
16965 : #endif
16966 : use pm_kind, only: LKC => LK1
16967 : logical(LKC) , intent(out) :: rand(:,:,:)
16968 : logical(LKC) , intent(in) :: lb, ub
16969 : type(xoshiro256ssg_type) , intent(inout) :: rng
16970 : end subroutine
16971 : #endif
16972 :
16973 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
16974 :
16975 : #if CK5_ENABLED
16976 : PURE module subroutine setUnifRandRNGGLU_D3_CK5(rng, rand, lb, ub)
16977 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16978 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_CK5
16979 : #endif
16980 : use pm_kind, only: CKC => CK5
16981 : complex(CKC) , intent(out) :: rand(:,:,:)
16982 : complex(CKC) , intent(in) :: lb, ub
16983 : type(xoshiro256ssg_type) , intent(inout) :: rng
16984 : end subroutine
16985 : #endif
16986 :
16987 : #if CK4_ENABLED
16988 : PURE module subroutine setUnifRandRNGGLU_D3_CK4(rng, rand, lb, ub)
16989 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
16990 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_CK4
16991 : #endif
16992 : use pm_kind, only: CKC => CK4
16993 : complex(CKC) , intent(out) :: rand(:,:,:)
16994 : complex(CKC) , intent(in) :: lb, ub
16995 : type(xoshiro256ssg_type) , intent(inout) :: rng
16996 : end subroutine
16997 : #endif
16998 :
16999 : #if CK3_ENABLED
17000 : PURE module subroutine setUnifRandRNGGLU_D3_CK3(rng, rand, lb, ub)
17001 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17002 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_CK3
17003 : #endif
17004 : use pm_kind, only: CKC => CK3
17005 : complex(CKC) , intent(out) :: rand(:,:,:)
17006 : complex(CKC) , intent(in) :: lb, ub
17007 : type(xoshiro256ssg_type) , intent(inout) :: rng
17008 : end subroutine
17009 : #endif
17010 :
17011 : #if CK2_ENABLED
17012 : PURE module subroutine setUnifRandRNGGLU_D3_CK2(rng, rand, lb, ub)
17013 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17014 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_CK2
17015 : #endif
17016 : use pm_kind, only: CKC => CK2
17017 : complex(CKC) , intent(out) :: rand(:,:,:)
17018 : complex(CKC) , intent(in) :: lb, ub
17019 : type(xoshiro256ssg_type) , intent(inout) :: rng
17020 : end subroutine
17021 : #endif
17022 :
17023 : #if CK1_ENABLED
17024 : PURE module subroutine setUnifRandRNGGLU_D3_CK1(rng, rand, lb, ub)
17025 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17026 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_CK1
17027 : #endif
17028 : use pm_kind, only: CKC => CK1
17029 : complex(CKC) , intent(out) :: rand(:,:,:)
17030 : complex(CKC) , intent(in) :: lb, ub
17031 : type(xoshiro256ssg_type) , intent(inout) :: rng
17032 : end subroutine
17033 : #endif
17034 :
17035 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17036 :
17037 : #if RK5_ENABLED
17038 : PURE module subroutine setUnifRandRNGGLU_D3_RK5(rng, rand, lb, ub)
17039 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17040 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_RK5
17041 : #endif
17042 : use pm_kind, only: RKC => RK5
17043 : real(RKC) , intent(out) :: rand(:,:,:)
17044 : real(RKC) , intent(in) :: lb, ub
17045 : type(xoshiro256ssg_type) , intent(inout) :: rng
17046 : end subroutine
17047 : #endif
17048 :
17049 : #if RK4_ENABLED
17050 : PURE module subroutine setUnifRandRNGGLU_D3_RK4(rng, rand, lb, ub)
17051 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17052 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_RK4
17053 : #endif
17054 : use pm_kind, only: RKC => RK4
17055 : real(RKC) , intent(out) :: rand(:,:,:)
17056 : real(RKC) , intent(in) :: lb, ub
17057 : type(xoshiro256ssg_type) , intent(inout) :: rng
17058 : end subroutine
17059 : #endif
17060 :
17061 : #if RK3_ENABLED
17062 : PURE module subroutine setUnifRandRNGGLU_D3_RK3(rng, rand, lb, ub)
17063 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17064 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_RK3
17065 : #endif
17066 : use pm_kind, only: RKC => RK3
17067 : real(RKC) , intent(out) :: rand(:,:,:)
17068 : real(RKC) , intent(in) :: lb, ub
17069 : type(xoshiro256ssg_type) , intent(inout) :: rng
17070 : end subroutine
17071 : #endif
17072 :
17073 : #if RK2_ENABLED
17074 : PURE module subroutine setUnifRandRNGGLU_D3_RK2(rng, rand, lb, ub)
17075 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17076 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_RK2
17077 : #endif
17078 : use pm_kind, only: RKC => RK2
17079 : real(RKC) , intent(out) :: rand(:,:,:)
17080 : real(RKC) , intent(in) :: lb, ub
17081 : type(xoshiro256ssg_type) , intent(inout) :: rng
17082 : end subroutine
17083 : #endif
17084 :
17085 : #if RK1_ENABLED
17086 : PURE module subroutine setUnifRandRNGGLU_D3_RK1(rng, rand, lb, ub)
17087 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17088 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGGLU_D3_RK1
17089 : #endif
17090 : use pm_kind, only: RKC => RK1
17091 : real(RKC) , intent(out) :: rand(:,:,:)
17092 : real(RKC) , intent(in) :: lb, ub
17093 : type(xoshiro256ssg_type) , intent(inout) :: rng
17094 : end subroutine
17095 : #endif
17096 :
17097 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17098 :
17099 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17100 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17101 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17102 :
17103 : end interface
17104 :
17105 : ! RNGS
17106 :
17107 : interface setUnifRand
17108 :
17109 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17110 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17111 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17112 :
17113 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17114 :
17115 : #if SK5_ENABLED
17116 : PURE elemental module subroutine setUnifRandRNGXDD_D0_SK5(rng, rand)
17117 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17118 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_SK5
17119 : #endif
17120 : use pm_kind, only: SKC => SK5
17121 : character(*,SKC) , intent(out) :: rand
17122 : type(xoshiro256ssw_type) , intent(inout) :: rng
17123 : end subroutine
17124 : #endif
17125 :
17126 : #if SK4_ENABLED
17127 : PURE elemental module subroutine setUnifRandRNGXDD_D0_SK4(rng, rand)
17128 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17129 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_SK4
17130 : #endif
17131 : use pm_kind, only: SKC => SK4
17132 : character(*,SKC) , intent(out) :: rand
17133 : type(xoshiro256ssw_type) , intent(inout) :: rng
17134 : end subroutine
17135 : #endif
17136 :
17137 : #if SK3_ENABLED
17138 : PURE elemental module subroutine setUnifRandRNGXDD_D0_SK3(rng, rand)
17139 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17140 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_SK3
17141 : #endif
17142 : use pm_kind, only: SKC => SK3
17143 : character(*,SKC) , intent(out) :: rand
17144 : type(xoshiro256ssw_type) , intent(inout) :: rng
17145 : end subroutine
17146 : #endif
17147 :
17148 : #if SK2_ENABLED
17149 : PURE elemental module subroutine setUnifRandRNGXDD_D0_SK2(rng, rand)
17150 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17151 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_SK2
17152 : #endif
17153 : use pm_kind, only: SKC => SK2
17154 : character(*,SKC) , intent(out) :: rand
17155 : type(xoshiro256ssw_type) , intent(inout) :: rng
17156 : end subroutine
17157 : #endif
17158 :
17159 : #if SK1_ENABLED
17160 : PURE elemental module subroutine setUnifRandRNGXDD_D0_SK1(rng, rand)
17161 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17162 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_SK1
17163 : #endif
17164 : use pm_kind, only: SKC => SK1
17165 : character(*,SKC) , intent(out) :: rand
17166 : type(xoshiro256ssw_type) , intent(inout) :: rng
17167 : end subroutine
17168 : #endif
17169 :
17170 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17171 :
17172 : #if IK5_ENABLED
17173 : PURE elemental module subroutine setUnifRandRNGXDD_D0_IK5(rng, rand)
17174 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17175 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_IK5
17176 : #endif
17177 : use pm_kind, only: IKC => IK5
17178 : integer(IKC) , intent(out) :: rand
17179 : type(xoshiro256ssw_type) , intent(inout) :: rng
17180 : end subroutine
17181 : #endif
17182 :
17183 : #if IK4_ENABLED
17184 : PURE elemental module subroutine setUnifRandRNGXDD_D0_IK4(rng, rand)
17185 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17186 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_IK4
17187 : #endif
17188 : use pm_kind, only: IKC => IK4
17189 : integer(IKC) , intent(out) :: rand
17190 : type(xoshiro256ssw_type) , intent(inout) :: rng
17191 : end subroutine
17192 : #endif
17193 :
17194 : #if IK3_ENABLED
17195 : PURE elemental module subroutine setUnifRandRNGXDD_D0_IK3(rng, rand)
17196 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17197 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_IK3
17198 : #endif
17199 : use pm_kind, only: IKC => IK3
17200 : integer(IKC) , intent(out) :: rand
17201 : type(xoshiro256ssw_type) , intent(inout) :: rng
17202 : end subroutine
17203 : #endif
17204 :
17205 : #if IK2_ENABLED
17206 : PURE elemental module subroutine setUnifRandRNGXDD_D0_IK2(rng, rand)
17207 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17208 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_IK2
17209 : #endif
17210 : use pm_kind, only: IKC => IK2
17211 : integer(IKC) , intent(out) :: rand
17212 : type(xoshiro256ssw_type) , intent(inout) :: rng
17213 : end subroutine
17214 : #endif
17215 :
17216 : #if IK1_ENABLED
17217 : PURE elemental module subroutine setUnifRandRNGXDD_D0_IK1(rng, rand)
17218 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17219 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_IK1
17220 : #endif
17221 : use pm_kind, only: IKC => IK1
17222 : integer(IKC) , intent(out) :: rand
17223 : type(xoshiro256ssw_type) , intent(inout) :: rng
17224 : end subroutine
17225 : #endif
17226 :
17227 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17228 :
17229 : #if LK5_ENABLED
17230 : PURE elemental module subroutine setUnifRandRNGXDD_D0_LK5(rng, rand)
17231 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17232 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_LK5
17233 : #endif
17234 : use pm_kind, only: LKC => LK5
17235 : logical(LKC) , intent(out) :: rand
17236 : type(xoshiro256ssw_type) , intent(inout) :: rng
17237 : end subroutine
17238 : #endif
17239 :
17240 : #if LK4_ENABLED
17241 : PURE elemental module subroutine setUnifRandRNGXDD_D0_LK4(rng, rand)
17242 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17243 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_LK4
17244 : #endif
17245 : use pm_kind, only: LKC => LK4
17246 : logical(LKC) , intent(out) :: rand
17247 : type(xoshiro256ssw_type) , intent(inout) :: rng
17248 : end subroutine
17249 : #endif
17250 :
17251 : #if LK3_ENABLED
17252 : PURE elemental module subroutine setUnifRandRNGXDD_D0_LK3(rng, rand)
17253 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17254 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_LK3
17255 : #endif
17256 : use pm_kind, only: LKC => LK3
17257 : logical(LKC) , intent(out) :: rand
17258 : type(xoshiro256ssw_type) , intent(inout) :: rng
17259 : end subroutine
17260 : #endif
17261 :
17262 : #if LK2_ENABLED
17263 : PURE elemental module subroutine setUnifRandRNGXDD_D0_LK2(rng, rand)
17264 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17265 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_LK2
17266 : #endif
17267 : use pm_kind, only: LKC => LK2
17268 : logical(LKC) , intent(out) :: rand
17269 : type(xoshiro256ssw_type) , intent(inout) :: rng
17270 : end subroutine
17271 : #endif
17272 :
17273 : #if LK1_ENABLED
17274 : PURE elemental module subroutine setUnifRandRNGXDD_D0_LK1(rng, rand)
17275 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17276 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_LK1
17277 : #endif
17278 : use pm_kind, only: LKC => LK1
17279 : logical(LKC) , intent(out) :: rand
17280 : type(xoshiro256ssw_type) , intent(inout) :: rng
17281 : end subroutine
17282 : #endif
17283 :
17284 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17285 :
17286 : #if CK5_ENABLED
17287 : PURE elemental module subroutine setUnifRandRNGXDD_D0_CK5(rng, rand)
17288 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17289 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_CK5
17290 : #endif
17291 : use pm_kind, only: CKC => CK5
17292 : complex(CKC) , intent(out) :: rand
17293 : type(xoshiro256ssw_type) , intent(inout) :: rng
17294 : end subroutine
17295 : #endif
17296 :
17297 : #if CK4_ENABLED
17298 : PURE elemental module subroutine setUnifRandRNGXDD_D0_CK4(rng, rand)
17299 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17300 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_CK4
17301 : #endif
17302 : use pm_kind, only: CKC => CK4
17303 : complex(CKC) , intent(out) :: rand
17304 : type(xoshiro256ssw_type) , intent(inout) :: rng
17305 : end subroutine
17306 : #endif
17307 :
17308 : #if CK3_ENABLED
17309 : PURE elemental module subroutine setUnifRandRNGXDD_D0_CK3(rng, rand)
17310 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17311 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_CK3
17312 : #endif
17313 : use pm_kind, only: CKC => CK3
17314 : complex(CKC) , intent(out) :: rand
17315 : type(xoshiro256ssw_type) , intent(inout) :: rng
17316 : end subroutine
17317 : #endif
17318 :
17319 : #if CK2_ENABLED
17320 : PURE elemental module subroutine setUnifRandRNGXDD_D0_CK2(rng, rand)
17321 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17322 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_CK2
17323 : #endif
17324 : use pm_kind, only: CKC => CK2
17325 : complex(CKC) , intent(out) :: rand
17326 : type(xoshiro256ssw_type) , intent(inout) :: rng
17327 : end subroutine
17328 : #endif
17329 :
17330 : #if CK1_ENABLED
17331 : PURE elemental module subroutine setUnifRandRNGXDD_D0_CK1(rng, rand)
17332 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17333 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_CK1
17334 : #endif
17335 : use pm_kind, only: CKC => CK1
17336 : complex(CKC) , intent(out) :: rand
17337 : type(xoshiro256ssw_type) , intent(inout) :: rng
17338 : end subroutine
17339 : #endif
17340 :
17341 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17342 :
17343 : #if RK5_ENABLED
17344 : PURE elemental module subroutine setUnifRandRNGXDD_D0_RK5(rng, rand)
17345 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17346 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_RK5
17347 : #endif
17348 : use pm_kind, only: RKC => RK5
17349 : real(RKC) , intent(out) :: rand
17350 : type(xoshiro256ssw_type) , intent(inout) :: rng
17351 : end subroutine
17352 : #endif
17353 :
17354 : #if RK4_ENABLED
17355 : PURE elemental module subroutine setUnifRandRNGXDD_D0_RK4(rng, rand)
17356 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17357 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_RK4
17358 : #endif
17359 : use pm_kind, only: RKC => RK4
17360 : real(RKC) , intent(out) :: rand
17361 : type(xoshiro256ssw_type) , intent(inout) :: rng
17362 : end subroutine
17363 : #endif
17364 :
17365 : #if RK3_ENABLED
17366 : PURE elemental module subroutine setUnifRandRNGXDD_D0_RK3(rng, rand)
17367 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17368 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_RK3
17369 : #endif
17370 : use pm_kind, only: RKC => RK3
17371 : real(RKC) , intent(out) :: rand
17372 : type(xoshiro256ssw_type) , intent(inout) :: rng
17373 : end subroutine
17374 : #endif
17375 :
17376 : #if RK2_ENABLED
17377 : PURE elemental module subroutine setUnifRandRNGXDD_D0_RK2(rng, rand)
17378 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17379 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_RK2
17380 : #endif
17381 : use pm_kind, only: RKC => RK2
17382 : real(RKC) , intent(out) :: rand
17383 : type(xoshiro256ssw_type) , intent(inout) :: rng
17384 : end subroutine
17385 : #endif
17386 :
17387 : #if RK1_ENABLED
17388 : PURE elemental module subroutine setUnifRandRNGXDD_D0_RK1(rng, rand)
17389 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17390 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D0_RK1
17391 : #endif
17392 : use pm_kind, only: RKC => RK1
17393 : real(RKC) , intent(out) :: rand
17394 : type(xoshiro256ssw_type) , intent(inout) :: rng
17395 : end subroutine
17396 : #endif
17397 :
17398 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17399 :
17400 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17401 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17402 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17403 :
17404 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17405 :
17406 : #if SK5_ENABLED
17407 : PURE elemental module subroutine setUnifRandRNGXLU_D0_SK5(rng, rand, lb, ub)
17408 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17409 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_SK5
17410 : #endif
17411 : use pm_kind, only: SKC => SK5
17412 : character(*,SKC) , intent(out) :: rand
17413 : character(*,SKC) , intent(in) :: lb, ub
17414 : type(xoshiro256ssw_type) , intent(inout) :: rng
17415 : end subroutine
17416 : #endif
17417 :
17418 : #if SK4_ENABLED
17419 : PURE elemental module subroutine setUnifRandRNGXLU_D0_SK4(rng, rand, lb, ub)
17420 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17421 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_SK4
17422 : #endif
17423 : use pm_kind, only: SKC => SK4
17424 : character(*,SKC) , intent(out) :: rand
17425 : character(*,SKC) , intent(in) :: lb, ub
17426 : type(xoshiro256ssw_type) , intent(inout) :: rng
17427 : end subroutine
17428 : #endif
17429 :
17430 : #if SK3_ENABLED
17431 : PURE elemental module subroutine setUnifRandRNGXLU_D0_SK3(rng, rand, lb, ub)
17432 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17433 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_SK3
17434 : #endif
17435 : use pm_kind, only: SKC => SK3
17436 : character(*,SKC) , intent(out) :: rand
17437 : character(*,SKC) , intent(in) :: lb, ub
17438 : type(xoshiro256ssw_type) , intent(inout) :: rng
17439 : end subroutine
17440 : #endif
17441 :
17442 : #if SK2_ENABLED
17443 : PURE elemental module subroutine setUnifRandRNGXLU_D0_SK2(rng, rand, lb, ub)
17444 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17445 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_SK2
17446 : #endif
17447 : use pm_kind, only: SKC => SK2
17448 : character(*,SKC) , intent(out) :: rand
17449 : character(*,SKC) , intent(in) :: lb, ub
17450 : type(xoshiro256ssw_type) , intent(inout) :: rng
17451 : end subroutine
17452 : #endif
17453 :
17454 : #if SK1_ENABLED
17455 : PURE elemental module subroutine setUnifRandRNGXLU_D0_SK1(rng, rand, lb, ub)
17456 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17457 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_SK1
17458 : #endif
17459 : use pm_kind, only: SKC => SK1
17460 : character(*,SKC) , intent(out) :: rand
17461 : character(*,SKC) , intent(in) :: lb, ub
17462 : type(xoshiro256ssw_type) , intent(inout) :: rng
17463 : end subroutine
17464 : #endif
17465 :
17466 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17467 :
17468 : #if IK5_ENABLED
17469 : PURE elemental module subroutine setUnifRandRNGXLU_D0_IK5(rng, rand, lb, ub)
17470 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17471 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_IK5
17472 : #endif
17473 : use pm_kind, only: IKC => IK5
17474 : integer(IKC) , intent(out) :: rand
17475 : integer(IKC) , intent(in) :: lb, ub
17476 : type(xoshiro256ssw_type) , intent(inout) :: rng
17477 : end subroutine
17478 : #endif
17479 :
17480 : #if IK4_ENABLED
17481 : PURE elemental module subroutine setUnifRandRNGXLU_D0_IK4(rng, rand, lb, ub)
17482 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17483 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_IK4
17484 : #endif
17485 : use pm_kind, only: IKC => IK4
17486 : integer(IKC) , intent(out) :: rand
17487 : integer(IKC) , intent(in) :: lb, ub
17488 : type(xoshiro256ssw_type) , intent(inout) :: rng
17489 : end subroutine
17490 : #endif
17491 :
17492 : #if IK3_ENABLED
17493 : PURE elemental module subroutine setUnifRandRNGXLU_D0_IK3(rng, rand, lb, ub)
17494 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17495 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_IK3
17496 : #endif
17497 : use pm_kind, only: IKC => IK3
17498 : integer(IKC) , intent(out) :: rand
17499 : integer(IKC) , intent(in) :: lb, ub
17500 : type(xoshiro256ssw_type) , intent(inout) :: rng
17501 : end subroutine
17502 : #endif
17503 :
17504 : #if IK2_ENABLED
17505 : PURE elemental module subroutine setUnifRandRNGXLU_D0_IK2(rng, rand, lb, ub)
17506 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17507 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_IK2
17508 : #endif
17509 : use pm_kind, only: IKC => IK2
17510 : integer(IKC) , intent(out) :: rand
17511 : integer(IKC) , intent(in) :: lb, ub
17512 : type(xoshiro256ssw_type) , intent(inout) :: rng
17513 : end subroutine
17514 : #endif
17515 :
17516 : #if IK1_ENABLED
17517 : PURE elemental module subroutine setUnifRandRNGXLU_D0_IK1(rng, rand, lb, ub)
17518 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17519 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_IK1
17520 : #endif
17521 : use pm_kind, only: IKC => IK1
17522 : integer(IKC) , intent(out) :: rand
17523 : integer(IKC) , intent(in) :: lb, ub
17524 : type(xoshiro256ssw_type) , intent(inout) :: rng
17525 : end subroutine
17526 : #endif
17527 :
17528 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17529 :
17530 : #if LK5_ENABLED
17531 : PURE elemental module subroutine setUnifRandRNGXLU_D0_LK5(rng, rand, lb, ub)
17532 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17533 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_LK5
17534 : #endif
17535 : use pm_kind, only: LKC => LK5
17536 : logical(LKC) , intent(out) :: rand
17537 : logical(LKC) , intent(in) :: lb, ub
17538 : type(xoshiro256ssw_type) , intent(inout) :: rng
17539 : end subroutine
17540 : #endif
17541 :
17542 : #if LK4_ENABLED
17543 : PURE elemental module subroutine setUnifRandRNGXLU_D0_LK4(rng, rand, lb, ub)
17544 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17545 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_LK4
17546 : #endif
17547 : use pm_kind, only: LKC => LK4
17548 : logical(LKC) , intent(out) :: rand
17549 : logical(LKC) , intent(in) :: lb, ub
17550 : type(xoshiro256ssw_type) , intent(inout) :: rng
17551 : end subroutine
17552 : #endif
17553 :
17554 : #if LK3_ENABLED
17555 : PURE elemental module subroutine setUnifRandRNGXLU_D0_LK3(rng, rand, lb, ub)
17556 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17557 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_LK3
17558 : #endif
17559 : use pm_kind, only: LKC => LK3
17560 : logical(LKC) , intent(out) :: rand
17561 : logical(LKC) , intent(in) :: lb, ub
17562 : type(xoshiro256ssw_type) , intent(inout) :: rng
17563 : end subroutine
17564 : #endif
17565 :
17566 : #if LK2_ENABLED
17567 : PURE elemental module subroutine setUnifRandRNGXLU_D0_LK2(rng, rand, lb, ub)
17568 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17569 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_LK2
17570 : #endif
17571 : use pm_kind, only: LKC => LK2
17572 : logical(LKC) , intent(out) :: rand
17573 : logical(LKC) , intent(in) :: lb, ub
17574 : type(xoshiro256ssw_type) , intent(inout) :: rng
17575 : end subroutine
17576 : #endif
17577 :
17578 : #if LK1_ENABLED
17579 : PURE elemental module subroutine setUnifRandRNGXLU_D0_LK1(rng, rand, lb, ub)
17580 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17581 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_LK1
17582 : #endif
17583 : use pm_kind, only: LKC => LK1
17584 : logical(LKC) , intent(out) :: rand
17585 : logical(LKC) , intent(in) :: lb, ub
17586 : type(xoshiro256ssw_type) , intent(inout) :: rng
17587 : end subroutine
17588 : #endif
17589 :
17590 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17591 :
17592 : #if CK5_ENABLED
17593 : PURE elemental module subroutine setUnifRandRNGXLU_D0_CK5(rng, rand, lb, ub)
17594 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17595 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_CK5
17596 : #endif
17597 : use pm_kind, only: CKC => CK5
17598 : complex(CKC) , intent(out) :: rand
17599 : complex(CKC) , intent(in) :: lb, ub
17600 : type(xoshiro256ssw_type) , intent(inout) :: rng
17601 : end subroutine
17602 : #endif
17603 :
17604 : #if CK4_ENABLED
17605 : PURE elemental module subroutine setUnifRandRNGXLU_D0_CK4(rng, rand, lb, ub)
17606 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17607 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_CK4
17608 : #endif
17609 : use pm_kind, only: CKC => CK4
17610 : complex(CKC) , intent(out) :: rand
17611 : complex(CKC) , intent(in) :: lb, ub
17612 : type(xoshiro256ssw_type) , intent(inout) :: rng
17613 : end subroutine
17614 : #endif
17615 :
17616 : #if CK3_ENABLED
17617 : PURE elemental module subroutine setUnifRandRNGXLU_D0_CK3(rng, rand, lb, ub)
17618 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17619 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_CK3
17620 : #endif
17621 : use pm_kind, only: CKC => CK3
17622 : complex(CKC) , intent(out) :: rand
17623 : complex(CKC) , intent(in) :: lb, ub
17624 : type(xoshiro256ssw_type) , intent(inout) :: rng
17625 : end subroutine
17626 : #endif
17627 :
17628 : #if CK2_ENABLED
17629 : PURE elemental module subroutine setUnifRandRNGXLU_D0_CK2(rng, rand, lb, ub)
17630 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17631 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_CK2
17632 : #endif
17633 : use pm_kind, only: CKC => CK2
17634 : complex(CKC) , intent(out) :: rand
17635 : complex(CKC) , intent(in) :: lb, ub
17636 : type(xoshiro256ssw_type) , intent(inout) :: rng
17637 : end subroutine
17638 : #endif
17639 :
17640 : #if CK1_ENABLED
17641 : PURE elemental module subroutine setUnifRandRNGXLU_D0_CK1(rng, rand, lb, ub)
17642 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17643 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_CK1
17644 : #endif
17645 : use pm_kind, only: CKC => CK1
17646 : complex(CKC) , intent(out) :: rand
17647 : complex(CKC) , intent(in) :: lb, ub
17648 : type(xoshiro256ssw_type) , intent(inout) :: rng
17649 : end subroutine
17650 : #endif
17651 :
17652 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17653 :
17654 : #if RK5_ENABLED
17655 : PURE elemental module subroutine setUnifRandRNGXLU_D0_RK5(rng, rand, lb, ub)
17656 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17657 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_RK5
17658 : #endif
17659 : use pm_kind, only: RKC => RK5
17660 : real(RKC) , intent(out) :: rand
17661 : real(RKC) , intent(in) :: lb, ub
17662 : type(xoshiro256ssw_type) , intent(inout) :: rng
17663 : end subroutine
17664 : #endif
17665 :
17666 : #if RK4_ENABLED
17667 : PURE elemental module subroutine setUnifRandRNGXLU_D0_RK4(rng, rand, lb, ub)
17668 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17669 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_RK4
17670 : #endif
17671 : use pm_kind, only: RKC => RK4
17672 : real(RKC) , intent(out) :: rand
17673 : real(RKC) , intent(in) :: lb, ub
17674 : type(xoshiro256ssw_type) , intent(inout) :: rng
17675 : end subroutine
17676 : #endif
17677 :
17678 : #if RK3_ENABLED
17679 : PURE elemental module subroutine setUnifRandRNGXLU_D0_RK3(rng, rand, lb, ub)
17680 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17681 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_RK3
17682 : #endif
17683 : use pm_kind, only: RKC => RK3
17684 : real(RKC) , intent(out) :: rand
17685 : real(RKC) , intent(in) :: lb, ub
17686 : type(xoshiro256ssw_type) , intent(inout) :: rng
17687 : end subroutine
17688 : #endif
17689 :
17690 : #if RK2_ENABLED
17691 : PURE elemental module subroutine setUnifRandRNGXLU_D0_RK2(rng, rand, lb, ub)
17692 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17693 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_RK2
17694 : #endif
17695 : use pm_kind, only: RKC => RK2
17696 : real(RKC) , intent(out) :: rand
17697 : real(RKC) , intent(in) :: lb, ub
17698 : type(xoshiro256ssw_type) , intent(inout) :: rng
17699 : end subroutine
17700 : #endif
17701 :
17702 : #if RK1_ENABLED
17703 : PURE elemental module subroutine setUnifRandRNGXLU_D0_RK1(rng, rand, lb, ub)
17704 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17705 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D0_RK1
17706 : #endif
17707 : use pm_kind, only: RKC => RK1
17708 : real(RKC) , intent(out) :: rand
17709 : real(RKC) , intent(in) :: lb, ub
17710 : type(xoshiro256ssw_type) , intent(inout) :: rng
17711 : end subroutine
17712 : #endif
17713 :
17714 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17715 :
17716 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17717 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17718 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17719 :
17720 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17721 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17722 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17723 :
17724 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17725 :
17726 : #if SK5_ENABLED
17727 : PURE module subroutine setUnifRandRNGXDD_D1_SK5(rng, rand)
17728 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17729 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_SK5
17730 : #endif
17731 : use pm_kind, only: SKC => SK5
17732 : character(*,SKC) , intent(out) :: rand(:)
17733 : type(xoshiro256ssw_type) , intent(inout) :: rng
17734 : end subroutine
17735 : #endif
17736 :
17737 : #if SK4_ENABLED
17738 : PURE module subroutine setUnifRandRNGXDD_D1_SK4(rng, rand)
17739 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17740 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_SK4
17741 : #endif
17742 : use pm_kind, only: SKC => SK4
17743 : character(*,SKC) , intent(out) :: rand(:)
17744 : type(xoshiro256ssw_type) , intent(inout) :: rng
17745 : end subroutine
17746 : #endif
17747 :
17748 : #if SK3_ENABLED
17749 : PURE module subroutine setUnifRandRNGXDD_D1_SK3(rng, rand)
17750 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17751 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_SK3
17752 : #endif
17753 : use pm_kind, only: SKC => SK3
17754 : character(*,SKC) , intent(out) :: rand(:)
17755 : type(xoshiro256ssw_type) , intent(inout) :: rng
17756 : end subroutine
17757 : #endif
17758 :
17759 : #if SK2_ENABLED
17760 : PURE module subroutine setUnifRandRNGXDD_D1_SK2(rng, rand)
17761 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17762 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_SK2
17763 : #endif
17764 : use pm_kind, only: SKC => SK2
17765 : character(*,SKC) , intent(out) :: rand(:)
17766 : type(xoshiro256ssw_type) , intent(inout) :: rng
17767 : end subroutine
17768 : #endif
17769 :
17770 : #if SK1_ENABLED
17771 : PURE module subroutine setUnifRandRNGXDD_D1_SK1(rng, rand)
17772 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17773 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_SK1
17774 : #endif
17775 : use pm_kind, only: SKC => SK1
17776 : character(*,SKC) , intent(out) :: rand(:)
17777 : type(xoshiro256ssw_type) , intent(inout) :: rng
17778 : end subroutine
17779 : #endif
17780 :
17781 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17782 :
17783 : #if IK5_ENABLED
17784 : PURE module subroutine setUnifRandRNGXDD_D1_IK5(rng, rand)
17785 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17786 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_IK5
17787 : #endif
17788 : use pm_kind, only: IKC => IK5
17789 : integer(IKC) , intent(out) :: rand(:)
17790 : type(xoshiro256ssw_type) , intent(inout) :: rng
17791 : end subroutine
17792 : #endif
17793 :
17794 : #if IK4_ENABLED
17795 : PURE module subroutine setUnifRandRNGXDD_D1_IK4(rng, rand)
17796 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17797 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_IK4
17798 : #endif
17799 : use pm_kind, only: IKC => IK4
17800 : integer(IKC) , intent(out) :: rand(:)
17801 : type(xoshiro256ssw_type) , intent(inout) :: rng
17802 : end subroutine
17803 : #endif
17804 :
17805 : #if IK3_ENABLED
17806 : PURE module subroutine setUnifRandRNGXDD_D1_IK3(rng, rand)
17807 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17808 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_IK3
17809 : #endif
17810 : use pm_kind, only: IKC => IK3
17811 : integer(IKC) , intent(out) :: rand(:)
17812 : type(xoshiro256ssw_type) , intent(inout) :: rng
17813 : end subroutine
17814 : #endif
17815 :
17816 : #if IK2_ENABLED
17817 : PURE module subroutine setUnifRandRNGXDD_D1_IK2(rng, rand)
17818 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17819 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_IK2
17820 : #endif
17821 : use pm_kind, only: IKC => IK2
17822 : integer(IKC) , intent(out) :: rand(:)
17823 : type(xoshiro256ssw_type) , intent(inout) :: rng
17824 : end subroutine
17825 : #endif
17826 :
17827 : #if IK1_ENABLED
17828 : PURE module subroutine setUnifRandRNGXDD_D1_IK1(rng, rand)
17829 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17830 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_IK1
17831 : #endif
17832 : use pm_kind, only: IKC => IK1
17833 : integer(IKC) , intent(out) :: rand(:)
17834 : type(xoshiro256ssw_type) , intent(inout) :: rng
17835 : end subroutine
17836 : #endif
17837 :
17838 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17839 :
17840 : #if LK5_ENABLED
17841 : PURE module subroutine setUnifRandRNGXDD_D1_LK5(rng, rand)
17842 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17843 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_LK5
17844 : #endif
17845 : use pm_kind, only: LKC => LK5
17846 : logical(LKC) , intent(out) :: rand(:)
17847 : type(xoshiro256ssw_type) , intent(inout) :: rng
17848 : end subroutine
17849 : #endif
17850 :
17851 : #if LK4_ENABLED
17852 : PURE module subroutine setUnifRandRNGXDD_D1_LK4(rng, rand)
17853 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17854 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_LK4
17855 : #endif
17856 : use pm_kind, only: LKC => LK4
17857 : logical(LKC) , intent(out) :: rand(:)
17858 : type(xoshiro256ssw_type) , intent(inout) :: rng
17859 : end subroutine
17860 : #endif
17861 :
17862 : #if LK3_ENABLED
17863 : PURE module subroutine setUnifRandRNGXDD_D1_LK3(rng, rand)
17864 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17865 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_LK3
17866 : #endif
17867 : use pm_kind, only: LKC => LK3
17868 : logical(LKC) , intent(out) :: rand(:)
17869 : type(xoshiro256ssw_type) , intent(inout) :: rng
17870 : end subroutine
17871 : #endif
17872 :
17873 : #if LK2_ENABLED
17874 : PURE module subroutine setUnifRandRNGXDD_D1_LK2(rng, rand)
17875 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17876 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_LK2
17877 : #endif
17878 : use pm_kind, only: LKC => LK2
17879 : logical(LKC) , intent(out) :: rand(:)
17880 : type(xoshiro256ssw_type) , intent(inout) :: rng
17881 : end subroutine
17882 : #endif
17883 :
17884 : #if LK1_ENABLED
17885 : PURE module subroutine setUnifRandRNGXDD_D1_LK1(rng, rand)
17886 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17887 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_LK1
17888 : #endif
17889 : use pm_kind, only: LKC => LK1
17890 : logical(LKC) , intent(out) :: rand(:)
17891 : type(xoshiro256ssw_type) , intent(inout) :: rng
17892 : end subroutine
17893 : #endif
17894 :
17895 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17896 :
17897 : #if CK5_ENABLED
17898 : PURE module subroutine setUnifRandRNGXDD_D1_CK5(rng, rand)
17899 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17900 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_CK5
17901 : #endif
17902 : use pm_kind, only: CKC => CK5
17903 : complex(CKC) , intent(out) :: rand(:)
17904 : type(xoshiro256ssw_type) , intent(inout) :: rng
17905 : end subroutine
17906 : #endif
17907 :
17908 : #if CK4_ENABLED
17909 : PURE module subroutine setUnifRandRNGXDD_D1_CK4(rng, rand)
17910 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17911 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_CK4
17912 : #endif
17913 : use pm_kind, only: CKC => CK4
17914 : complex(CKC) , intent(out) :: rand(:)
17915 : type(xoshiro256ssw_type) , intent(inout) :: rng
17916 : end subroutine
17917 : #endif
17918 :
17919 : #if CK3_ENABLED
17920 : PURE module subroutine setUnifRandRNGXDD_D1_CK3(rng, rand)
17921 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17922 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_CK3
17923 : #endif
17924 : use pm_kind, only: CKC => CK3
17925 : complex(CKC) , intent(out) :: rand(:)
17926 : type(xoshiro256ssw_type) , intent(inout) :: rng
17927 : end subroutine
17928 : #endif
17929 :
17930 : #if CK2_ENABLED
17931 : PURE module subroutine setUnifRandRNGXDD_D1_CK2(rng, rand)
17932 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17933 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_CK2
17934 : #endif
17935 : use pm_kind, only: CKC => CK2
17936 : complex(CKC) , intent(out) :: rand(:)
17937 : type(xoshiro256ssw_type) , intent(inout) :: rng
17938 : end subroutine
17939 : #endif
17940 :
17941 : #if CK1_ENABLED
17942 : PURE module subroutine setUnifRandRNGXDD_D1_CK1(rng, rand)
17943 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17944 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_CK1
17945 : #endif
17946 : use pm_kind, only: CKC => CK1
17947 : complex(CKC) , intent(out) :: rand(:)
17948 : type(xoshiro256ssw_type) , intent(inout) :: rng
17949 : end subroutine
17950 : #endif
17951 :
17952 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
17953 :
17954 : #if RK5_ENABLED
17955 : PURE module subroutine setUnifRandRNGXDD_D1_RK5(rng, rand)
17956 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17957 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_RK5
17958 : #endif
17959 : use pm_kind, only: RKC => RK5
17960 : real(RKC) , intent(out) :: rand(:)
17961 : type(xoshiro256ssw_type) , intent(inout) :: rng
17962 : end subroutine
17963 : #endif
17964 :
17965 : #if RK4_ENABLED
17966 : PURE module subroutine setUnifRandRNGXDD_D1_RK4(rng, rand)
17967 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17968 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_RK4
17969 : #endif
17970 : use pm_kind, only: RKC => RK4
17971 : real(RKC) , intent(out) :: rand(:)
17972 : type(xoshiro256ssw_type) , intent(inout) :: rng
17973 : end subroutine
17974 : #endif
17975 :
17976 : #if RK3_ENABLED
17977 : PURE module subroutine setUnifRandRNGXDD_D1_RK3(rng, rand)
17978 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17979 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_RK3
17980 : #endif
17981 : use pm_kind, only: RKC => RK3
17982 : real(RKC) , intent(out) :: rand(:)
17983 : type(xoshiro256ssw_type) , intent(inout) :: rng
17984 : end subroutine
17985 : #endif
17986 :
17987 : #if RK2_ENABLED
17988 : PURE module subroutine setUnifRandRNGXDD_D1_RK2(rng, rand)
17989 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
17990 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_RK2
17991 : #endif
17992 : use pm_kind, only: RKC => RK2
17993 : real(RKC) , intent(out) :: rand(:)
17994 : type(xoshiro256ssw_type) , intent(inout) :: rng
17995 : end subroutine
17996 : #endif
17997 :
17998 : #if RK1_ENABLED
17999 : PURE module subroutine setUnifRandRNGXDD_D1_RK1(rng, rand)
18000 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18001 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D1_RK1
18002 : #endif
18003 : use pm_kind, only: RKC => RK1
18004 : real(RKC) , intent(out) :: rand(:)
18005 : type(xoshiro256ssw_type) , intent(inout) :: rng
18006 : end subroutine
18007 : #endif
18008 :
18009 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18010 :
18011 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18012 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18013 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18014 :
18015 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18016 :
18017 : #if SK5_ENABLED
18018 : PURE module subroutine setUnifRandRNGXLU_D1_SK5(rng, rand, lb, ub)
18019 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18020 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_SK5
18021 : #endif
18022 : use pm_kind, only: SKC => SK5
18023 : character(*,SKC) , intent(out) :: rand(:)
18024 : character(*,SKC) , intent(in) :: lb, ub
18025 : type(xoshiro256ssw_type) , intent(inout) :: rng
18026 : end subroutine
18027 : #endif
18028 :
18029 : #if SK4_ENABLED
18030 : PURE module subroutine setUnifRandRNGXLU_D1_SK4(rng, rand, lb, ub)
18031 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18032 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_SK4
18033 : #endif
18034 : use pm_kind, only: SKC => SK4
18035 : character(*,SKC) , intent(out) :: rand(:)
18036 : character(*,SKC) , intent(in) :: lb, ub
18037 : type(xoshiro256ssw_type) , intent(inout) :: rng
18038 : end subroutine
18039 : #endif
18040 :
18041 : #if SK3_ENABLED
18042 : PURE module subroutine setUnifRandRNGXLU_D1_SK3(rng, rand, lb, ub)
18043 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18044 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_SK3
18045 : #endif
18046 : use pm_kind, only: SKC => SK3
18047 : character(*,SKC) , intent(out) :: rand(:)
18048 : character(*,SKC) , intent(in) :: lb, ub
18049 : type(xoshiro256ssw_type) , intent(inout) :: rng
18050 : end subroutine
18051 : #endif
18052 :
18053 : #if SK2_ENABLED
18054 : PURE module subroutine setUnifRandRNGXLU_D1_SK2(rng, rand, lb, ub)
18055 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18056 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_SK2
18057 : #endif
18058 : use pm_kind, only: SKC => SK2
18059 : character(*,SKC) , intent(out) :: rand(:)
18060 : character(*,SKC) , intent(in) :: lb, ub
18061 : type(xoshiro256ssw_type) , intent(inout) :: rng
18062 : end subroutine
18063 : #endif
18064 :
18065 : #if SK1_ENABLED
18066 : PURE module subroutine setUnifRandRNGXLU_D1_SK1(rng, rand, lb, ub)
18067 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18068 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_SK1
18069 : #endif
18070 : use pm_kind, only: SKC => SK1
18071 : character(*,SKC) , intent(out) :: rand(:)
18072 : character(*,SKC) , intent(in) :: lb, ub
18073 : type(xoshiro256ssw_type) , intent(inout) :: rng
18074 : end subroutine
18075 : #endif
18076 :
18077 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18078 :
18079 : #if IK5_ENABLED
18080 : PURE module subroutine setUnifRandRNGXLU_D1_IK5(rng, rand, lb, ub)
18081 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18082 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_IK5
18083 : #endif
18084 : use pm_kind, only: IKC => IK5
18085 : integer(IKC) , intent(out) :: rand(:)
18086 : integer(IKC) , intent(in) :: lb, ub
18087 : type(xoshiro256ssw_type) , intent(inout) :: rng
18088 : end subroutine
18089 : #endif
18090 :
18091 : #if IK4_ENABLED
18092 : PURE module subroutine setUnifRandRNGXLU_D1_IK4(rng, rand, lb, ub)
18093 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18094 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_IK4
18095 : #endif
18096 : use pm_kind, only: IKC => IK4
18097 : integer(IKC) , intent(out) :: rand(:)
18098 : integer(IKC) , intent(in) :: lb, ub
18099 : type(xoshiro256ssw_type) , intent(inout) :: rng
18100 : end subroutine
18101 : #endif
18102 :
18103 : #if IK3_ENABLED
18104 : PURE module subroutine setUnifRandRNGXLU_D1_IK3(rng, rand, lb, ub)
18105 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18106 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_IK3
18107 : #endif
18108 : use pm_kind, only: IKC => IK3
18109 : integer(IKC) , intent(out) :: rand(:)
18110 : integer(IKC) , intent(in) :: lb, ub
18111 : type(xoshiro256ssw_type) , intent(inout) :: rng
18112 : end subroutine
18113 : #endif
18114 :
18115 : #if IK2_ENABLED
18116 : PURE module subroutine setUnifRandRNGXLU_D1_IK2(rng, rand, lb, ub)
18117 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18118 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_IK2
18119 : #endif
18120 : use pm_kind, only: IKC => IK2
18121 : integer(IKC) , intent(out) :: rand(:)
18122 : integer(IKC) , intent(in) :: lb, ub
18123 : type(xoshiro256ssw_type) , intent(inout) :: rng
18124 : end subroutine
18125 : #endif
18126 :
18127 : #if IK1_ENABLED
18128 : PURE module subroutine setUnifRandRNGXLU_D1_IK1(rng, rand, lb, ub)
18129 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18130 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_IK1
18131 : #endif
18132 : use pm_kind, only: IKC => IK1
18133 : integer(IKC) , intent(out) :: rand(:)
18134 : integer(IKC) , intent(in) :: lb, ub
18135 : type(xoshiro256ssw_type) , intent(inout) :: rng
18136 : end subroutine
18137 : #endif
18138 :
18139 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18140 :
18141 : #if LK5_ENABLED
18142 : PURE module subroutine setUnifRandRNGXLU_D1_LK5(rng, rand, lb, ub)
18143 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18144 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_LK5
18145 : #endif
18146 : use pm_kind, only: LKC => LK5
18147 : logical(LKC) , intent(out) :: rand(:)
18148 : logical(LKC) , intent(in) :: lb, ub
18149 : type(xoshiro256ssw_type) , intent(inout) :: rng
18150 : end subroutine
18151 : #endif
18152 :
18153 : #if LK4_ENABLED
18154 : PURE module subroutine setUnifRandRNGXLU_D1_LK4(rng, rand, lb, ub)
18155 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18156 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_LK4
18157 : #endif
18158 : use pm_kind, only: LKC => LK4
18159 : logical(LKC) , intent(out) :: rand(:)
18160 : logical(LKC) , intent(in) :: lb, ub
18161 : type(xoshiro256ssw_type) , intent(inout) :: rng
18162 : end subroutine
18163 : #endif
18164 :
18165 : #if LK3_ENABLED
18166 : PURE module subroutine setUnifRandRNGXLU_D1_LK3(rng, rand, lb, ub)
18167 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18168 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_LK3
18169 : #endif
18170 : use pm_kind, only: LKC => LK3
18171 : logical(LKC) , intent(out) :: rand(:)
18172 : logical(LKC) , intent(in) :: lb, ub
18173 : type(xoshiro256ssw_type) , intent(inout) :: rng
18174 : end subroutine
18175 : #endif
18176 :
18177 : #if LK2_ENABLED
18178 : PURE module subroutine setUnifRandRNGXLU_D1_LK2(rng, rand, lb, ub)
18179 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18180 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_LK2
18181 : #endif
18182 : use pm_kind, only: LKC => LK2
18183 : logical(LKC) , intent(out) :: rand(:)
18184 : logical(LKC) , intent(in) :: lb, ub
18185 : type(xoshiro256ssw_type) , intent(inout) :: rng
18186 : end subroutine
18187 : #endif
18188 :
18189 : #if LK1_ENABLED
18190 : PURE module subroutine setUnifRandRNGXLU_D1_LK1(rng, rand, lb, ub)
18191 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18192 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_LK1
18193 : #endif
18194 : use pm_kind, only: LKC => LK1
18195 : logical(LKC) , intent(out) :: rand(:)
18196 : logical(LKC) , intent(in) :: lb, ub
18197 : type(xoshiro256ssw_type) , intent(inout) :: rng
18198 : end subroutine
18199 : #endif
18200 :
18201 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18202 :
18203 : #if CK5_ENABLED
18204 : PURE module subroutine setUnifRandRNGXLU_D1_CK5(rng, rand, lb, ub)
18205 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18206 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_CK5
18207 : #endif
18208 : use pm_kind, only: CKC => CK5
18209 : complex(CKC) , intent(out) :: rand(:)
18210 : complex(CKC) , intent(in) :: lb, ub
18211 : type(xoshiro256ssw_type) , intent(inout) :: rng
18212 : end subroutine
18213 : #endif
18214 :
18215 : #if CK4_ENABLED
18216 : PURE module subroutine setUnifRandRNGXLU_D1_CK4(rng, rand, lb, ub)
18217 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18218 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_CK4
18219 : #endif
18220 : use pm_kind, only: CKC => CK4
18221 : complex(CKC) , intent(out) :: rand(:)
18222 : complex(CKC) , intent(in) :: lb, ub
18223 : type(xoshiro256ssw_type) , intent(inout) :: rng
18224 : end subroutine
18225 : #endif
18226 :
18227 : #if CK3_ENABLED
18228 : PURE module subroutine setUnifRandRNGXLU_D1_CK3(rng, rand, lb, ub)
18229 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18230 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_CK3
18231 : #endif
18232 : use pm_kind, only: CKC => CK3
18233 : complex(CKC) , intent(out) :: rand(:)
18234 : complex(CKC) , intent(in) :: lb, ub
18235 : type(xoshiro256ssw_type) , intent(inout) :: rng
18236 : end subroutine
18237 : #endif
18238 :
18239 : #if CK2_ENABLED
18240 : PURE module subroutine setUnifRandRNGXLU_D1_CK2(rng, rand, lb, ub)
18241 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18242 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_CK2
18243 : #endif
18244 : use pm_kind, only: CKC => CK2
18245 : complex(CKC) , intent(out) :: rand(:)
18246 : complex(CKC) , intent(in) :: lb, ub
18247 : type(xoshiro256ssw_type) , intent(inout) :: rng
18248 : end subroutine
18249 : #endif
18250 :
18251 : #if CK1_ENABLED
18252 : PURE module subroutine setUnifRandRNGXLU_D1_CK1(rng, rand, lb, ub)
18253 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18254 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_CK1
18255 : #endif
18256 : use pm_kind, only: CKC => CK1
18257 : complex(CKC) , intent(out) :: rand(:)
18258 : complex(CKC) , intent(in) :: lb, ub
18259 : type(xoshiro256ssw_type) , intent(inout) :: rng
18260 : end subroutine
18261 : #endif
18262 :
18263 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18264 :
18265 : #if RK5_ENABLED
18266 : PURE module subroutine setUnifRandRNGXLU_D1_RK5(rng, rand, lb, ub)
18267 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18268 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_RK5
18269 : #endif
18270 : use pm_kind, only: RKC => RK5
18271 : real(RKC) , intent(out) :: rand(:)
18272 : real(RKC) , intent(in) :: lb, ub
18273 : type(xoshiro256ssw_type) , intent(inout) :: rng
18274 : end subroutine
18275 : #endif
18276 :
18277 : #if RK4_ENABLED
18278 : PURE module subroutine setUnifRandRNGXLU_D1_RK4(rng, rand, lb, ub)
18279 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18280 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_RK4
18281 : #endif
18282 : use pm_kind, only: RKC => RK4
18283 : real(RKC) , intent(out) :: rand(:)
18284 : real(RKC) , intent(in) :: lb, ub
18285 : type(xoshiro256ssw_type) , intent(inout) :: rng
18286 : end subroutine
18287 : #endif
18288 :
18289 : #if RK3_ENABLED
18290 : PURE module subroutine setUnifRandRNGXLU_D1_RK3(rng, rand, lb, ub)
18291 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18292 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_RK3
18293 : #endif
18294 : use pm_kind, only: RKC => RK3
18295 : real(RKC) , intent(out) :: rand(:)
18296 : real(RKC) , intent(in) :: lb, ub
18297 : type(xoshiro256ssw_type) , intent(inout) :: rng
18298 : end subroutine
18299 : #endif
18300 :
18301 : #if RK2_ENABLED
18302 : PURE module subroutine setUnifRandRNGXLU_D1_RK2(rng, rand, lb, ub)
18303 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18304 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_RK2
18305 : #endif
18306 : use pm_kind, only: RKC => RK2
18307 : real(RKC) , intent(out) :: rand(:)
18308 : real(RKC) , intent(in) :: lb, ub
18309 : type(xoshiro256ssw_type) , intent(inout) :: rng
18310 : end subroutine
18311 : #endif
18312 :
18313 : #if RK1_ENABLED
18314 : PURE module subroutine setUnifRandRNGXLU_D1_RK1(rng, rand, lb, ub)
18315 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18316 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D1_RK1
18317 : #endif
18318 : use pm_kind, only: RKC => RK1
18319 : real(RKC) , intent(out) :: rand(:)
18320 : real(RKC) , intent(in) :: lb, ub
18321 : type(xoshiro256ssw_type) , intent(inout) :: rng
18322 : end subroutine
18323 : #endif
18324 :
18325 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18326 :
18327 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18328 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18329 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18330 :
18331 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18332 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18333 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18334 :
18335 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18336 :
18337 : #if SK5_ENABLED
18338 : PURE module subroutine setUnifRandRNGXDD_D2_SK5(rng, rand)
18339 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18340 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_SK5
18341 : #endif
18342 : use pm_kind, only: SKC => SK5
18343 : character(*,SKC) , intent(out) :: rand(:,:)
18344 : type(xoshiro256ssw_type) , intent(inout) :: rng
18345 : end subroutine
18346 : #endif
18347 :
18348 : #if SK4_ENABLED
18349 : PURE module subroutine setUnifRandRNGXDD_D2_SK4(rng, rand)
18350 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18351 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_SK4
18352 : #endif
18353 : use pm_kind, only: SKC => SK4
18354 : character(*,SKC) , intent(out) :: rand(:,:)
18355 : type(xoshiro256ssw_type) , intent(inout) :: rng
18356 : end subroutine
18357 : #endif
18358 :
18359 : #if SK3_ENABLED
18360 : PURE module subroutine setUnifRandRNGXDD_D2_SK3(rng, rand)
18361 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18362 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_SK3
18363 : #endif
18364 : use pm_kind, only: SKC => SK3
18365 : character(*,SKC) , intent(out) :: rand(:,:)
18366 : type(xoshiro256ssw_type) , intent(inout) :: rng
18367 : end subroutine
18368 : #endif
18369 :
18370 : #if SK2_ENABLED
18371 : PURE module subroutine setUnifRandRNGXDD_D2_SK2(rng, rand)
18372 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18373 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_SK2
18374 : #endif
18375 : use pm_kind, only: SKC => SK2
18376 : character(*,SKC) , intent(out) :: rand(:,:)
18377 : type(xoshiro256ssw_type) , intent(inout) :: rng
18378 : end subroutine
18379 : #endif
18380 :
18381 : #if SK1_ENABLED
18382 : PURE module subroutine setUnifRandRNGXDD_D2_SK1(rng, rand)
18383 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18384 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_SK1
18385 : #endif
18386 : use pm_kind, only: SKC => SK1
18387 : character(*,SKC) , intent(out) :: rand(:,:)
18388 : type(xoshiro256ssw_type) , intent(inout) :: rng
18389 : end subroutine
18390 : #endif
18391 :
18392 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18393 :
18394 : #if IK5_ENABLED
18395 : PURE module subroutine setUnifRandRNGXDD_D2_IK5(rng, rand)
18396 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18397 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_IK5
18398 : #endif
18399 : use pm_kind, only: IKC => IK5
18400 : integer(IKC) , intent(out) :: rand(:,:)
18401 : type(xoshiro256ssw_type) , intent(inout) :: rng
18402 : end subroutine
18403 : #endif
18404 :
18405 : #if IK4_ENABLED
18406 : PURE module subroutine setUnifRandRNGXDD_D2_IK4(rng, rand)
18407 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18408 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_IK4
18409 : #endif
18410 : use pm_kind, only: IKC => IK4
18411 : integer(IKC) , intent(out) :: rand(:,:)
18412 : type(xoshiro256ssw_type) , intent(inout) :: rng
18413 : end subroutine
18414 : #endif
18415 :
18416 : #if IK3_ENABLED
18417 : PURE module subroutine setUnifRandRNGXDD_D2_IK3(rng, rand)
18418 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18419 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_IK3
18420 : #endif
18421 : use pm_kind, only: IKC => IK3
18422 : integer(IKC) , intent(out) :: rand(:,:)
18423 : type(xoshiro256ssw_type) , intent(inout) :: rng
18424 : end subroutine
18425 : #endif
18426 :
18427 : #if IK2_ENABLED
18428 : PURE module subroutine setUnifRandRNGXDD_D2_IK2(rng, rand)
18429 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18430 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_IK2
18431 : #endif
18432 : use pm_kind, only: IKC => IK2
18433 : integer(IKC) , intent(out) :: rand(:,:)
18434 : type(xoshiro256ssw_type) , intent(inout) :: rng
18435 : end subroutine
18436 : #endif
18437 :
18438 : #if IK1_ENABLED
18439 : PURE module subroutine setUnifRandRNGXDD_D2_IK1(rng, rand)
18440 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18441 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_IK1
18442 : #endif
18443 : use pm_kind, only: IKC => IK1
18444 : integer(IKC) , intent(out) :: rand(:,:)
18445 : type(xoshiro256ssw_type) , intent(inout) :: rng
18446 : end subroutine
18447 : #endif
18448 :
18449 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18450 :
18451 : #if LK5_ENABLED
18452 : PURE module subroutine setUnifRandRNGXDD_D2_LK5(rng, rand)
18453 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18454 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_LK5
18455 : #endif
18456 : use pm_kind, only: LKC => LK5
18457 : logical(LKC) , intent(out) :: rand(:,:)
18458 : type(xoshiro256ssw_type) , intent(inout) :: rng
18459 : end subroutine
18460 : #endif
18461 :
18462 : #if LK4_ENABLED
18463 : PURE module subroutine setUnifRandRNGXDD_D2_LK4(rng, rand)
18464 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18465 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_LK4
18466 : #endif
18467 : use pm_kind, only: LKC => LK4
18468 : logical(LKC) , intent(out) :: rand(:,:)
18469 : type(xoshiro256ssw_type) , intent(inout) :: rng
18470 : end subroutine
18471 : #endif
18472 :
18473 : #if LK3_ENABLED
18474 : PURE module subroutine setUnifRandRNGXDD_D2_LK3(rng, rand)
18475 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18476 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_LK3
18477 : #endif
18478 : use pm_kind, only: LKC => LK3
18479 : logical(LKC) , intent(out) :: rand(:,:)
18480 : type(xoshiro256ssw_type) , intent(inout) :: rng
18481 : end subroutine
18482 : #endif
18483 :
18484 : #if LK2_ENABLED
18485 : PURE module subroutine setUnifRandRNGXDD_D2_LK2(rng, rand)
18486 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18487 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_LK2
18488 : #endif
18489 : use pm_kind, only: LKC => LK2
18490 : logical(LKC) , intent(out) :: rand(:,:)
18491 : type(xoshiro256ssw_type) , intent(inout) :: rng
18492 : end subroutine
18493 : #endif
18494 :
18495 : #if LK1_ENABLED
18496 : PURE module subroutine setUnifRandRNGXDD_D2_LK1(rng, rand)
18497 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18498 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_LK1
18499 : #endif
18500 : use pm_kind, only: LKC => LK1
18501 : logical(LKC) , intent(out) :: rand(:,:)
18502 : type(xoshiro256ssw_type) , intent(inout) :: rng
18503 : end subroutine
18504 : #endif
18505 :
18506 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18507 :
18508 : #if CK5_ENABLED
18509 : PURE module subroutine setUnifRandRNGXDD_D2_CK5(rng, rand)
18510 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18511 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_CK5
18512 : #endif
18513 : use pm_kind, only: CKC => CK5
18514 : complex(CKC) , intent(out) :: rand(:,:)
18515 : type(xoshiro256ssw_type) , intent(inout) :: rng
18516 : end subroutine
18517 : #endif
18518 :
18519 : #if CK4_ENABLED
18520 : PURE module subroutine setUnifRandRNGXDD_D2_CK4(rng, rand)
18521 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18522 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_CK4
18523 : #endif
18524 : use pm_kind, only: CKC => CK4
18525 : complex(CKC) , intent(out) :: rand(:,:)
18526 : type(xoshiro256ssw_type) , intent(inout) :: rng
18527 : end subroutine
18528 : #endif
18529 :
18530 : #if CK3_ENABLED
18531 : PURE module subroutine setUnifRandRNGXDD_D2_CK3(rng, rand)
18532 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18533 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_CK3
18534 : #endif
18535 : use pm_kind, only: CKC => CK3
18536 : complex(CKC) , intent(out) :: rand(:,:)
18537 : type(xoshiro256ssw_type) , intent(inout) :: rng
18538 : end subroutine
18539 : #endif
18540 :
18541 : #if CK2_ENABLED
18542 : PURE module subroutine setUnifRandRNGXDD_D2_CK2(rng, rand)
18543 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18544 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_CK2
18545 : #endif
18546 : use pm_kind, only: CKC => CK2
18547 : complex(CKC) , intent(out) :: rand(:,:)
18548 : type(xoshiro256ssw_type) , intent(inout) :: rng
18549 : end subroutine
18550 : #endif
18551 :
18552 : #if CK1_ENABLED
18553 : PURE module subroutine setUnifRandRNGXDD_D2_CK1(rng, rand)
18554 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18555 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_CK1
18556 : #endif
18557 : use pm_kind, only: CKC => CK1
18558 : complex(CKC) , intent(out) :: rand(:,:)
18559 : type(xoshiro256ssw_type) , intent(inout) :: rng
18560 : end subroutine
18561 : #endif
18562 :
18563 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18564 :
18565 : #if RK5_ENABLED
18566 : PURE module subroutine setUnifRandRNGXDD_D2_RK5(rng, rand)
18567 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18568 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_RK5
18569 : #endif
18570 : use pm_kind, only: RKC => RK5
18571 : real(RKC) , intent(out) :: rand(:,:)
18572 : type(xoshiro256ssw_type) , intent(inout) :: rng
18573 : end subroutine
18574 : #endif
18575 :
18576 : #if RK4_ENABLED
18577 : PURE module subroutine setUnifRandRNGXDD_D2_RK4(rng, rand)
18578 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18579 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_RK4
18580 : #endif
18581 : use pm_kind, only: RKC => RK4
18582 : real(RKC) , intent(out) :: rand(:,:)
18583 : type(xoshiro256ssw_type) , intent(inout) :: rng
18584 : end subroutine
18585 : #endif
18586 :
18587 : #if RK3_ENABLED
18588 : PURE module subroutine setUnifRandRNGXDD_D2_RK3(rng, rand)
18589 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18590 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_RK3
18591 : #endif
18592 : use pm_kind, only: RKC => RK3
18593 : real(RKC) , intent(out) :: rand(:,:)
18594 : type(xoshiro256ssw_type) , intent(inout) :: rng
18595 : end subroutine
18596 : #endif
18597 :
18598 : #if RK2_ENABLED
18599 : PURE module subroutine setUnifRandRNGXDD_D2_RK2(rng, rand)
18600 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18601 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_RK2
18602 : #endif
18603 : use pm_kind, only: RKC => RK2
18604 : real(RKC) , intent(out) :: rand(:,:)
18605 : type(xoshiro256ssw_type) , intent(inout) :: rng
18606 : end subroutine
18607 : #endif
18608 :
18609 : #if RK1_ENABLED
18610 : PURE module subroutine setUnifRandRNGXDD_D2_RK1(rng, rand)
18611 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18612 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D2_RK1
18613 : #endif
18614 : use pm_kind, only: RKC => RK1
18615 : real(RKC) , intent(out) :: rand(:,:)
18616 : type(xoshiro256ssw_type) , intent(inout) :: rng
18617 : end subroutine
18618 : #endif
18619 :
18620 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18621 :
18622 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18623 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18624 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18625 :
18626 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18627 :
18628 : #if SK5_ENABLED
18629 : PURE module subroutine setUnifRandRNGXLU_D2_SK5(rng, rand, lb, ub)
18630 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18631 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_SK5
18632 : #endif
18633 : use pm_kind, only: SKC => SK5
18634 : character(*,SKC) , intent(out) :: rand(:,:)
18635 : character(*,SKC) , intent(in) :: lb, ub
18636 : type(xoshiro256ssw_type) , intent(inout) :: rng
18637 : end subroutine
18638 : #endif
18639 :
18640 : #if SK4_ENABLED
18641 : PURE module subroutine setUnifRandRNGXLU_D2_SK4(rng, rand, lb, ub)
18642 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18643 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_SK4
18644 : #endif
18645 : use pm_kind, only: SKC => SK4
18646 : character(*,SKC) , intent(out) :: rand(:,:)
18647 : character(*,SKC) , intent(in) :: lb, ub
18648 : type(xoshiro256ssw_type) , intent(inout) :: rng
18649 : end subroutine
18650 : #endif
18651 :
18652 : #if SK3_ENABLED
18653 : PURE module subroutine setUnifRandRNGXLU_D2_SK3(rng, rand, lb, ub)
18654 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18655 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_SK3
18656 : #endif
18657 : use pm_kind, only: SKC => SK3
18658 : character(*,SKC) , intent(out) :: rand(:,:)
18659 : character(*,SKC) , intent(in) :: lb, ub
18660 : type(xoshiro256ssw_type) , intent(inout) :: rng
18661 : end subroutine
18662 : #endif
18663 :
18664 : #if SK2_ENABLED
18665 : PURE module subroutine setUnifRandRNGXLU_D2_SK2(rng, rand, lb, ub)
18666 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18667 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_SK2
18668 : #endif
18669 : use pm_kind, only: SKC => SK2
18670 : character(*,SKC) , intent(out) :: rand(:,:)
18671 : character(*,SKC) , intent(in) :: lb, ub
18672 : type(xoshiro256ssw_type) , intent(inout) :: rng
18673 : end subroutine
18674 : #endif
18675 :
18676 : #if SK1_ENABLED
18677 : PURE module subroutine setUnifRandRNGXLU_D2_SK1(rng, rand, lb, ub)
18678 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18679 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_SK1
18680 : #endif
18681 : use pm_kind, only: SKC => SK1
18682 : character(*,SKC) , intent(out) :: rand(:,:)
18683 : character(*,SKC) , intent(in) :: lb, ub
18684 : type(xoshiro256ssw_type) , intent(inout) :: rng
18685 : end subroutine
18686 : #endif
18687 :
18688 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18689 :
18690 : #if IK5_ENABLED
18691 : PURE module subroutine setUnifRandRNGXLU_D2_IK5(rng, rand, lb, ub)
18692 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18693 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_IK5
18694 : #endif
18695 : use pm_kind, only: IKC => IK5
18696 : integer(IKC) , intent(out) :: rand(:,:)
18697 : integer(IKC) , intent(in) :: lb, ub
18698 : type(xoshiro256ssw_type) , intent(inout) :: rng
18699 : end subroutine
18700 : #endif
18701 :
18702 : #if IK4_ENABLED
18703 : PURE module subroutine setUnifRandRNGXLU_D2_IK4(rng, rand, lb, ub)
18704 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18705 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_IK4
18706 : #endif
18707 : use pm_kind, only: IKC => IK4
18708 : integer(IKC) , intent(out) :: rand(:,:)
18709 : integer(IKC) , intent(in) :: lb, ub
18710 : type(xoshiro256ssw_type) , intent(inout) :: rng
18711 : end subroutine
18712 : #endif
18713 :
18714 : #if IK3_ENABLED
18715 : PURE module subroutine setUnifRandRNGXLU_D2_IK3(rng, rand, lb, ub)
18716 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18717 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_IK3
18718 : #endif
18719 : use pm_kind, only: IKC => IK3
18720 : integer(IKC) , intent(out) :: rand(:,:)
18721 : integer(IKC) , intent(in) :: lb, ub
18722 : type(xoshiro256ssw_type) , intent(inout) :: rng
18723 : end subroutine
18724 : #endif
18725 :
18726 : #if IK2_ENABLED
18727 : PURE module subroutine setUnifRandRNGXLU_D2_IK2(rng, rand, lb, ub)
18728 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18729 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_IK2
18730 : #endif
18731 : use pm_kind, only: IKC => IK2
18732 : integer(IKC) , intent(out) :: rand(:,:)
18733 : integer(IKC) , intent(in) :: lb, ub
18734 : type(xoshiro256ssw_type) , intent(inout) :: rng
18735 : end subroutine
18736 : #endif
18737 :
18738 : #if IK1_ENABLED
18739 : PURE module subroutine setUnifRandRNGXLU_D2_IK1(rng, rand, lb, ub)
18740 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18741 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_IK1
18742 : #endif
18743 : use pm_kind, only: IKC => IK1
18744 : integer(IKC) , intent(out) :: rand(:,:)
18745 : integer(IKC) , intent(in) :: lb, ub
18746 : type(xoshiro256ssw_type) , intent(inout) :: rng
18747 : end subroutine
18748 : #endif
18749 :
18750 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18751 :
18752 : #if LK5_ENABLED
18753 : PURE module subroutine setUnifRandRNGXLU_D2_LK5(rng, rand, lb, ub)
18754 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18755 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_LK5
18756 : #endif
18757 : use pm_kind, only: LKC => LK5
18758 : logical(LKC) , intent(out) :: rand(:,:)
18759 : logical(LKC) , intent(in) :: lb, ub
18760 : type(xoshiro256ssw_type) , intent(inout) :: rng
18761 : end subroutine
18762 : #endif
18763 :
18764 : #if LK4_ENABLED
18765 : PURE module subroutine setUnifRandRNGXLU_D2_LK4(rng, rand, lb, ub)
18766 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18767 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_LK4
18768 : #endif
18769 : use pm_kind, only: LKC => LK4
18770 : logical(LKC) , intent(out) :: rand(:,:)
18771 : logical(LKC) , intent(in) :: lb, ub
18772 : type(xoshiro256ssw_type) , intent(inout) :: rng
18773 : end subroutine
18774 : #endif
18775 :
18776 : #if LK3_ENABLED
18777 : PURE module subroutine setUnifRandRNGXLU_D2_LK3(rng, rand, lb, ub)
18778 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18779 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_LK3
18780 : #endif
18781 : use pm_kind, only: LKC => LK3
18782 : logical(LKC) , intent(out) :: rand(:,:)
18783 : logical(LKC) , intent(in) :: lb, ub
18784 : type(xoshiro256ssw_type) , intent(inout) :: rng
18785 : end subroutine
18786 : #endif
18787 :
18788 : #if LK2_ENABLED
18789 : PURE module subroutine setUnifRandRNGXLU_D2_LK2(rng, rand, lb, ub)
18790 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18791 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_LK2
18792 : #endif
18793 : use pm_kind, only: LKC => LK2
18794 : logical(LKC) , intent(out) :: rand(:,:)
18795 : logical(LKC) , intent(in) :: lb, ub
18796 : type(xoshiro256ssw_type) , intent(inout) :: rng
18797 : end subroutine
18798 : #endif
18799 :
18800 : #if LK1_ENABLED
18801 : PURE module subroutine setUnifRandRNGXLU_D2_LK1(rng, rand, lb, ub)
18802 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18803 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_LK1
18804 : #endif
18805 : use pm_kind, only: LKC => LK1
18806 : logical(LKC) , intent(out) :: rand(:,:)
18807 : logical(LKC) , intent(in) :: lb, ub
18808 : type(xoshiro256ssw_type) , intent(inout) :: rng
18809 : end subroutine
18810 : #endif
18811 :
18812 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18813 :
18814 : #if CK5_ENABLED
18815 : PURE module subroutine setUnifRandRNGXLU_D2_CK5(rng, rand, lb, ub)
18816 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18817 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_CK5
18818 : #endif
18819 : use pm_kind, only: CKC => CK5
18820 : complex(CKC) , intent(out) :: rand(:,:)
18821 : complex(CKC) , intent(in) :: lb, ub
18822 : type(xoshiro256ssw_type) , intent(inout) :: rng
18823 : end subroutine
18824 : #endif
18825 :
18826 : #if CK4_ENABLED
18827 : PURE module subroutine setUnifRandRNGXLU_D2_CK4(rng, rand, lb, ub)
18828 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18829 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_CK4
18830 : #endif
18831 : use pm_kind, only: CKC => CK4
18832 : complex(CKC) , intent(out) :: rand(:,:)
18833 : complex(CKC) , intent(in) :: lb, ub
18834 : type(xoshiro256ssw_type) , intent(inout) :: rng
18835 : end subroutine
18836 : #endif
18837 :
18838 : #if CK3_ENABLED
18839 : PURE module subroutine setUnifRandRNGXLU_D2_CK3(rng, rand, lb, ub)
18840 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18841 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_CK3
18842 : #endif
18843 : use pm_kind, only: CKC => CK3
18844 : complex(CKC) , intent(out) :: rand(:,:)
18845 : complex(CKC) , intent(in) :: lb, ub
18846 : type(xoshiro256ssw_type) , intent(inout) :: rng
18847 : end subroutine
18848 : #endif
18849 :
18850 : #if CK2_ENABLED
18851 : PURE module subroutine setUnifRandRNGXLU_D2_CK2(rng, rand, lb, ub)
18852 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18853 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_CK2
18854 : #endif
18855 : use pm_kind, only: CKC => CK2
18856 : complex(CKC) , intent(out) :: rand(:,:)
18857 : complex(CKC) , intent(in) :: lb, ub
18858 : type(xoshiro256ssw_type) , intent(inout) :: rng
18859 : end subroutine
18860 : #endif
18861 :
18862 : #if CK1_ENABLED
18863 : PURE module subroutine setUnifRandRNGXLU_D2_CK1(rng, rand, lb, ub)
18864 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18865 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_CK1
18866 : #endif
18867 : use pm_kind, only: CKC => CK1
18868 : complex(CKC) , intent(out) :: rand(:,:)
18869 : complex(CKC) , intent(in) :: lb, ub
18870 : type(xoshiro256ssw_type) , intent(inout) :: rng
18871 : end subroutine
18872 : #endif
18873 :
18874 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18875 :
18876 : #if RK5_ENABLED
18877 : PURE module subroutine setUnifRandRNGXLU_D2_RK5(rng, rand, lb, ub)
18878 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18879 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_RK5
18880 : #endif
18881 : use pm_kind, only: RKC => RK5
18882 : real(RKC) , intent(out) :: rand(:,:)
18883 : real(RKC) , intent(in) :: lb, ub
18884 : type(xoshiro256ssw_type) , intent(inout) :: rng
18885 : end subroutine
18886 : #endif
18887 :
18888 : #if RK4_ENABLED
18889 : PURE module subroutine setUnifRandRNGXLU_D2_RK4(rng, rand, lb, ub)
18890 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18891 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_RK4
18892 : #endif
18893 : use pm_kind, only: RKC => RK4
18894 : real(RKC) , intent(out) :: rand(:,:)
18895 : real(RKC) , intent(in) :: lb, ub
18896 : type(xoshiro256ssw_type) , intent(inout) :: rng
18897 : end subroutine
18898 : #endif
18899 :
18900 : #if RK3_ENABLED
18901 : PURE module subroutine setUnifRandRNGXLU_D2_RK3(rng, rand, lb, ub)
18902 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18903 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_RK3
18904 : #endif
18905 : use pm_kind, only: RKC => RK3
18906 : real(RKC) , intent(out) :: rand(:,:)
18907 : real(RKC) , intent(in) :: lb, ub
18908 : type(xoshiro256ssw_type) , intent(inout) :: rng
18909 : end subroutine
18910 : #endif
18911 :
18912 : #if RK2_ENABLED
18913 : PURE module subroutine setUnifRandRNGXLU_D2_RK2(rng, rand, lb, ub)
18914 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18915 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_RK2
18916 : #endif
18917 : use pm_kind, only: RKC => RK2
18918 : real(RKC) , intent(out) :: rand(:,:)
18919 : real(RKC) , intent(in) :: lb, ub
18920 : type(xoshiro256ssw_type) , intent(inout) :: rng
18921 : end subroutine
18922 : #endif
18923 :
18924 : #if RK1_ENABLED
18925 : PURE module subroutine setUnifRandRNGXLU_D2_RK1(rng, rand, lb, ub)
18926 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18927 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D2_RK1
18928 : #endif
18929 : use pm_kind, only: RKC => RK1
18930 : real(RKC) , intent(out) :: rand(:,:)
18931 : real(RKC) , intent(in) :: lb, ub
18932 : type(xoshiro256ssw_type) , intent(inout) :: rng
18933 : end subroutine
18934 : #endif
18935 :
18936 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18937 :
18938 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18939 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18940 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18941 :
18942 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18943 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18944 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18945 :
18946 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
18947 :
18948 : #if SK5_ENABLED
18949 : PURE module subroutine setUnifRandRNGXDD_D3_SK5(rng, rand)
18950 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18951 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_SK5
18952 : #endif
18953 : use pm_kind, only: SKC => SK5
18954 : character(*,SKC) , intent(out) :: rand(:,:,:)
18955 : type(xoshiro256ssw_type) , intent(inout) :: rng
18956 : end subroutine
18957 : #endif
18958 :
18959 : #if SK4_ENABLED
18960 : PURE module subroutine setUnifRandRNGXDD_D3_SK4(rng, rand)
18961 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18962 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_SK4
18963 : #endif
18964 : use pm_kind, only: SKC => SK4
18965 : character(*,SKC) , intent(out) :: rand(:,:,:)
18966 : type(xoshiro256ssw_type) , intent(inout) :: rng
18967 : end subroutine
18968 : #endif
18969 :
18970 : #if SK3_ENABLED
18971 : PURE module subroutine setUnifRandRNGXDD_D3_SK3(rng, rand)
18972 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18973 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_SK3
18974 : #endif
18975 : use pm_kind, only: SKC => SK3
18976 : character(*,SKC) , intent(out) :: rand(:,:,:)
18977 : type(xoshiro256ssw_type) , intent(inout) :: rng
18978 : end subroutine
18979 : #endif
18980 :
18981 : #if SK2_ENABLED
18982 : PURE module subroutine setUnifRandRNGXDD_D3_SK2(rng, rand)
18983 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18984 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_SK2
18985 : #endif
18986 : use pm_kind, only: SKC => SK2
18987 : character(*,SKC) , intent(out) :: rand(:,:,:)
18988 : type(xoshiro256ssw_type) , intent(inout) :: rng
18989 : end subroutine
18990 : #endif
18991 :
18992 : #if SK1_ENABLED
18993 : PURE module subroutine setUnifRandRNGXDD_D3_SK1(rng, rand)
18994 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
18995 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_SK1
18996 : #endif
18997 : use pm_kind, only: SKC => SK1
18998 : character(*,SKC) , intent(out) :: rand(:,:,:)
18999 : type(xoshiro256ssw_type) , intent(inout) :: rng
19000 : end subroutine
19001 : #endif
19002 :
19003 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19004 :
19005 : #if IK5_ENABLED
19006 : PURE module subroutine setUnifRandRNGXDD_D3_IK5(rng, rand)
19007 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19008 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_IK5
19009 : #endif
19010 : use pm_kind, only: IKC => IK5
19011 : integer(IKC) , intent(out) :: rand(:,:,:)
19012 : type(xoshiro256ssw_type) , intent(inout) :: rng
19013 : end subroutine
19014 : #endif
19015 :
19016 : #if IK4_ENABLED
19017 : PURE module subroutine setUnifRandRNGXDD_D3_IK4(rng, rand)
19018 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19019 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_IK4
19020 : #endif
19021 : use pm_kind, only: IKC => IK4
19022 : integer(IKC) , intent(out) :: rand(:,:,:)
19023 : type(xoshiro256ssw_type) , intent(inout) :: rng
19024 : end subroutine
19025 : #endif
19026 :
19027 : #if IK3_ENABLED
19028 : PURE module subroutine setUnifRandRNGXDD_D3_IK3(rng, rand)
19029 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19030 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_IK3
19031 : #endif
19032 : use pm_kind, only: IKC => IK3
19033 : integer(IKC) , intent(out) :: rand(:,:,:)
19034 : type(xoshiro256ssw_type) , intent(inout) :: rng
19035 : end subroutine
19036 : #endif
19037 :
19038 : #if IK2_ENABLED
19039 : PURE module subroutine setUnifRandRNGXDD_D3_IK2(rng, rand)
19040 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19041 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_IK2
19042 : #endif
19043 : use pm_kind, only: IKC => IK2
19044 : integer(IKC) , intent(out) :: rand(:,:,:)
19045 : type(xoshiro256ssw_type) , intent(inout) :: rng
19046 : end subroutine
19047 : #endif
19048 :
19049 : #if IK1_ENABLED
19050 : PURE module subroutine setUnifRandRNGXDD_D3_IK1(rng, rand)
19051 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19052 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_IK1
19053 : #endif
19054 : use pm_kind, only: IKC => IK1
19055 : integer(IKC) , intent(out) :: rand(:,:,:)
19056 : type(xoshiro256ssw_type) , intent(inout) :: rng
19057 : end subroutine
19058 : #endif
19059 :
19060 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19061 :
19062 : #if LK5_ENABLED
19063 : PURE module subroutine setUnifRandRNGXDD_D3_LK5(rng, rand)
19064 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19065 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_LK5
19066 : #endif
19067 : use pm_kind, only: LKC => LK5
19068 : logical(LKC) , intent(out) :: rand(:,:,:)
19069 : type(xoshiro256ssw_type) , intent(inout) :: rng
19070 : end subroutine
19071 : #endif
19072 :
19073 : #if LK4_ENABLED
19074 : PURE module subroutine setUnifRandRNGXDD_D3_LK4(rng, rand)
19075 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19076 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_LK4
19077 : #endif
19078 : use pm_kind, only: LKC => LK4
19079 : logical(LKC) , intent(out) :: rand(:,:,:)
19080 : type(xoshiro256ssw_type) , intent(inout) :: rng
19081 : end subroutine
19082 : #endif
19083 :
19084 : #if LK3_ENABLED
19085 : PURE module subroutine setUnifRandRNGXDD_D3_LK3(rng, rand)
19086 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19087 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_LK3
19088 : #endif
19089 : use pm_kind, only: LKC => LK3
19090 : logical(LKC) , intent(out) :: rand(:,:,:)
19091 : type(xoshiro256ssw_type) , intent(inout) :: rng
19092 : end subroutine
19093 : #endif
19094 :
19095 : #if LK2_ENABLED
19096 : PURE module subroutine setUnifRandRNGXDD_D3_LK2(rng, rand)
19097 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19098 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_LK2
19099 : #endif
19100 : use pm_kind, only: LKC => LK2
19101 : logical(LKC) , intent(out) :: rand(:,:,:)
19102 : type(xoshiro256ssw_type) , intent(inout) :: rng
19103 : end subroutine
19104 : #endif
19105 :
19106 : #if LK1_ENABLED
19107 : PURE module subroutine setUnifRandRNGXDD_D3_LK1(rng, rand)
19108 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19109 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_LK1
19110 : #endif
19111 : use pm_kind, only: LKC => LK1
19112 : logical(LKC) , intent(out) :: rand(:,:,:)
19113 : type(xoshiro256ssw_type) , intent(inout) :: rng
19114 : end subroutine
19115 : #endif
19116 :
19117 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19118 :
19119 : #if CK5_ENABLED
19120 : PURE module subroutine setUnifRandRNGXDD_D3_CK5(rng, rand)
19121 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19122 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_CK5
19123 : #endif
19124 : use pm_kind, only: CKC => CK5
19125 : complex(CKC) , intent(out) :: rand(:,:,:)
19126 : type(xoshiro256ssw_type) , intent(inout) :: rng
19127 : end subroutine
19128 : #endif
19129 :
19130 : #if CK4_ENABLED
19131 : PURE module subroutine setUnifRandRNGXDD_D3_CK4(rng, rand)
19132 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19133 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_CK4
19134 : #endif
19135 : use pm_kind, only: CKC => CK4
19136 : complex(CKC) , intent(out) :: rand(:,:,:)
19137 : type(xoshiro256ssw_type) , intent(inout) :: rng
19138 : end subroutine
19139 : #endif
19140 :
19141 : #if CK3_ENABLED
19142 : PURE module subroutine setUnifRandRNGXDD_D3_CK3(rng, rand)
19143 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19144 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_CK3
19145 : #endif
19146 : use pm_kind, only: CKC => CK3
19147 : complex(CKC) , intent(out) :: rand(:,:,:)
19148 : type(xoshiro256ssw_type) , intent(inout) :: rng
19149 : end subroutine
19150 : #endif
19151 :
19152 : #if CK2_ENABLED
19153 : PURE module subroutine setUnifRandRNGXDD_D3_CK2(rng, rand)
19154 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19155 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_CK2
19156 : #endif
19157 : use pm_kind, only: CKC => CK2
19158 : complex(CKC) , intent(out) :: rand(:,:,:)
19159 : type(xoshiro256ssw_type) , intent(inout) :: rng
19160 : end subroutine
19161 : #endif
19162 :
19163 : #if CK1_ENABLED
19164 : PURE module subroutine setUnifRandRNGXDD_D3_CK1(rng, rand)
19165 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19166 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_CK1
19167 : #endif
19168 : use pm_kind, only: CKC => CK1
19169 : complex(CKC) , intent(out) :: rand(:,:,:)
19170 : type(xoshiro256ssw_type) , intent(inout) :: rng
19171 : end subroutine
19172 : #endif
19173 :
19174 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19175 :
19176 : #if RK5_ENABLED
19177 : PURE module subroutine setUnifRandRNGXDD_D3_RK5(rng, rand)
19178 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19179 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_RK5
19180 : #endif
19181 : use pm_kind, only: RKC => RK5
19182 : real(RKC) , intent(out) :: rand(:,:,:)
19183 : type(xoshiro256ssw_type) , intent(inout) :: rng
19184 : end subroutine
19185 : #endif
19186 :
19187 : #if RK4_ENABLED
19188 : PURE module subroutine setUnifRandRNGXDD_D3_RK4(rng, rand)
19189 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19190 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_RK4
19191 : #endif
19192 : use pm_kind, only: RKC => RK4
19193 : real(RKC) , intent(out) :: rand(:,:,:)
19194 : type(xoshiro256ssw_type) , intent(inout) :: rng
19195 : end subroutine
19196 : #endif
19197 :
19198 : #if RK3_ENABLED
19199 : PURE module subroutine setUnifRandRNGXDD_D3_RK3(rng, rand)
19200 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19201 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_RK3
19202 : #endif
19203 : use pm_kind, only: RKC => RK3
19204 : real(RKC) , intent(out) :: rand(:,:,:)
19205 : type(xoshiro256ssw_type) , intent(inout) :: rng
19206 : end subroutine
19207 : #endif
19208 :
19209 : #if RK2_ENABLED
19210 : PURE module subroutine setUnifRandRNGXDD_D3_RK2(rng, rand)
19211 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19212 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_RK2
19213 : #endif
19214 : use pm_kind, only: RKC => RK2
19215 : real(RKC) , intent(out) :: rand(:,:,:)
19216 : type(xoshiro256ssw_type) , intent(inout) :: rng
19217 : end subroutine
19218 : #endif
19219 :
19220 : #if RK1_ENABLED
19221 : PURE module subroutine setUnifRandRNGXDD_D3_RK1(rng, rand)
19222 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19223 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXDD_D3_RK1
19224 : #endif
19225 : use pm_kind, only: RKC => RK1
19226 : real(RKC) , intent(out) :: rand(:,:,:)
19227 : type(xoshiro256ssw_type) , intent(inout) :: rng
19228 : end subroutine
19229 : #endif
19230 :
19231 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19232 :
19233 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19234 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19235 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19236 :
19237 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19238 :
19239 : #if SK5_ENABLED
19240 : PURE module subroutine setUnifRandRNGXLU_D3_SK5(rng, rand, lb, ub)
19241 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19242 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_SK5
19243 : #endif
19244 : use pm_kind, only: SKC => SK5
19245 : character(*,SKC) , intent(out) :: rand(:,:,:)
19246 : character(*,SKC) , intent(in) :: lb, ub
19247 : type(xoshiro256ssw_type) , intent(inout) :: rng
19248 : end subroutine
19249 : #endif
19250 :
19251 : #if SK4_ENABLED
19252 : PURE module subroutine setUnifRandRNGXLU_D3_SK4(rng, rand, lb, ub)
19253 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19254 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_SK4
19255 : #endif
19256 : use pm_kind, only: SKC => SK4
19257 : character(*,SKC) , intent(out) :: rand(:,:,:)
19258 : character(*,SKC) , intent(in) :: lb, ub
19259 : type(xoshiro256ssw_type) , intent(inout) :: rng
19260 : end subroutine
19261 : #endif
19262 :
19263 : #if SK3_ENABLED
19264 : PURE module subroutine setUnifRandRNGXLU_D3_SK3(rng, rand, lb, ub)
19265 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19266 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_SK3
19267 : #endif
19268 : use pm_kind, only: SKC => SK3
19269 : character(*,SKC) , intent(out) :: rand(:,:,:)
19270 : character(*,SKC) , intent(in) :: lb, ub
19271 : type(xoshiro256ssw_type) , intent(inout) :: rng
19272 : end subroutine
19273 : #endif
19274 :
19275 : #if SK2_ENABLED
19276 : PURE module subroutine setUnifRandRNGXLU_D3_SK2(rng, rand, lb, ub)
19277 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19278 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_SK2
19279 : #endif
19280 : use pm_kind, only: SKC => SK2
19281 : character(*,SKC) , intent(out) :: rand(:,:,:)
19282 : character(*,SKC) , intent(in) :: lb, ub
19283 : type(xoshiro256ssw_type) , intent(inout) :: rng
19284 : end subroutine
19285 : #endif
19286 :
19287 : #if SK1_ENABLED
19288 : PURE module subroutine setUnifRandRNGXLU_D3_SK1(rng, rand, lb, ub)
19289 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19290 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_SK1
19291 : #endif
19292 : use pm_kind, only: SKC => SK1
19293 : character(*,SKC) , intent(out) :: rand(:,:,:)
19294 : character(*,SKC) , intent(in) :: lb, ub
19295 : type(xoshiro256ssw_type) , intent(inout) :: rng
19296 : end subroutine
19297 : #endif
19298 :
19299 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19300 :
19301 : #if IK5_ENABLED
19302 : PURE module subroutine setUnifRandRNGXLU_D3_IK5(rng, rand, lb, ub)
19303 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19304 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_IK5
19305 : #endif
19306 : use pm_kind, only: IKC => IK5
19307 : integer(IKC) , intent(out) :: rand(:,:,:)
19308 : integer(IKC) , intent(in) :: lb, ub
19309 : type(xoshiro256ssw_type) , intent(inout) :: rng
19310 : end subroutine
19311 : #endif
19312 :
19313 : #if IK4_ENABLED
19314 : PURE module subroutine setUnifRandRNGXLU_D3_IK4(rng, rand, lb, ub)
19315 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19316 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_IK4
19317 : #endif
19318 : use pm_kind, only: IKC => IK4
19319 : integer(IKC) , intent(out) :: rand(:,:,:)
19320 : integer(IKC) , intent(in) :: lb, ub
19321 : type(xoshiro256ssw_type) , intent(inout) :: rng
19322 : end subroutine
19323 : #endif
19324 :
19325 : #if IK3_ENABLED
19326 : PURE module subroutine setUnifRandRNGXLU_D3_IK3(rng, rand, lb, ub)
19327 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19328 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_IK3
19329 : #endif
19330 : use pm_kind, only: IKC => IK3
19331 : integer(IKC) , intent(out) :: rand(:,:,:)
19332 : integer(IKC) , intent(in) :: lb, ub
19333 : type(xoshiro256ssw_type) , intent(inout) :: rng
19334 : end subroutine
19335 : #endif
19336 :
19337 : #if IK2_ENABLED
19338 : PURE module subroutine setUnifRandRNGXLU_D3_IK2(rng, rand, lb, ub)
19339 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19340 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_IK2
19341 : #endif
19342 : use pm_kind, only: IKC => IK2
19343 : integer(IKC) , intent(out) :: rand(:,:,:)
19344 : integer(IKC) , intent(in) :: lb, ub
19345 : type(xoshiro256ssw_type) , intent(inout) :: rng
19346 : end subroutine
19347 : #endif
19348 :
19349 : #if IK1_ENABLED
19350 : PURE module subroutine setUnifRandRNGXLU_D3_IK1(rng, rand, lb, ub)
19351 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19352 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_IK1
19353 : #endif
19354 : use pm_kind, only: IKC => IK1
19355 : integer(IKC) , intent(out) :: rand(:,:,:)
19356 : integer(IKC) , intent(in) :: lb, ub
19357 : type(xoshiro256ssw_type) , intent(inout) :: rng
19358 : end subroutine
19359 : #endif
19360 :
19361 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19362 :
19363 : #if LK5_ENABLED
19364 : PURE module subroutine setUnifRandRNGXLU_D3_LK5(rng, rand, lb, ub)
19365 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19366 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_LK5
19367 : #endif
19368 : use pm_kind, only: LKC => LK5
19369 : logical(LKC) , intent(out) :: rand(:,:,:)
19370 : logical(LKC) , intent(in) :: lb, ub
19371 : type(xoshiro256ssw_type) , intent(inout) :: rng
19372 : end subroutine
19373 : #endif
19374 :
19375 : #if LK4_ENABLED
19376 : PURE module subroutine setUnifRandRNGXLU_D3_LK4(rng, rand, lb, ub)
19377 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19378 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_LK4
19379 : #endif
19380 : use pm_kind, only: LKC => LK4
19381 : logical(LKC) , intent(out) :: rand(:,:,:)
19382 : logical(LKC) , intent(in) :: lb, ub
19383 : type(xoshiro256ssw_type) , intent(inout) :: rng
19384 : end subroutine
19385 : #endif
19386 :
19387 : #if LK3_ENABLED
19388 : PURE module subroutine setUnifRandRNGXLU_D3_LK3(rng, rand, lb, ub)
19389 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19390 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_LK3
19391 : #endif
19392 : use pm_kind, only: LKC => LK3
19393 : logical(LKC) , intent(out) :: rand(:,:,:)
19394 : logical(LKC) , intent(in) :: lb, ub
19395 : type(xoshiro256ssw_type) , intent(inout) :: rng
19396 : end subroutine
19397 : #endif
19398 :
19399 : #if LK2_ENABLED
19400 : PURE module subroutine setUnifRandRNGXLU_D3_LK2(rng, rand, lb, ub)
19401 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19402 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_LK2
19403 : #endif
19404 : use pm_kind, only: LKC => LK2
19405 : logical(LKC) , intent(out) :: rand(:,:,:)
19406 : logical(LKC) , intent(in) :: lb, ub
19407 : type(xoshiro256ssw_type) , intent(inout) :: rng
19408 : end subroutine
19409 : #endif
19410 :
19411 : #if LK1_ENABLED
19412 : PURE module subroutine setUnifRandRNGXLU_D3_LK1(rng, rand, lb, ub)
19413 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19414 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_LK1
19415 : #endif
19416 : use pm_kind, only: LKC => LK1
19417 : logical(LKC) , intent(out) :: rand(:,:,:)
19418 : logical(LKC) , intent(in) :: lb, ub
19419 : type(xoshiro256ssw_type) , intent(inout) :: rng
19420 : end subroutine
19421 : #endif
19422 :
19423 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19424 :
19425 : #if CK5_ENABLED
19426 : PURE module subroutine setUnifRandRNGXLU_D3_CK5(rng, rand, lb, ub)
19427 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19428 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_CK5
19429 : #endif
19430 : use pm_kind, only: CKC => CK5
19431 : complex(CKC) , intent(out) :: rand(:,:,:)
19432 : complex(CKC) , intent(in) :: lb, ub
19433 : type(xoshiro256ssw_type) , intent(inout) :: rng
19434 : end subroutine
19435 : #endif
19436 :
19437 : #if CK4_ENABLED
19438 : PURE module subroutine setUnifRandRNGXLU_D3_CK4(rng, rand, lb, ub)
19439 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19440 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_CK4
19441 : #endif
19442 : use pm_kind, only: CKC => CK4
19443 : complex(CKC) , intent(out) :: rand(:,:,:)
19444 : complex(CKC) , intent(in) :: lb, ub
19445 : type(xoshiro256ssw_type) , intent(inout) :: rng
19446 : end subroutine
19447 : #endif
19448 :
19449 : #if CK3_ENABLED
19450 : PURE module subroutine setUnifRandRNGXLU_D3_CK3(rng, rand, lb, ub)
19451 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19452 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_CK3
19453 : #endif
19454 : use pm_kind, only: CKC => CK3
19455 : complex(CKC) , intent(out) :: rand(:,:,:)
19456 : complex(CKC) , intent(in) :: lb, ub
19457 : type(xoshiro256ssw_type) , intent(inout) :: rng
19458 : end subroutine
19459 : #endif
19460 :
19461 : #if CK2_ENABLED
19462 : PURE module subroutine setUnifRandRNGXLU_D3_CK2(rng, rand, lb, ub)
19463 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19464 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_CK2
19465 : #endif
19466 : use pm_kind, only: CKC => CK2
19467 : complex(CKC) , intent(out) :: rand(:,:,:)
19468 : complex(CKC) , intent(in) :: lb, ub
19469 : type(xoshiro256ssw_type) , intent(inout) :: rng
19470 : end subroutine
19471 : #endif
19472 :
19473 : #if CK1_ENABLED
19474 : PURE module subroutine setUnifRandRNGXLU_D3_CK1(rng, rand, lb, ub)
19475 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19476 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_CK1
19477 : #endif
19478 : use pm_kind, only: CKC => CK1
19479 : complex(CKC) , intent(out) :: rand(:,:,:)
19480 : complex(CKC) , intent(in) :: lb, ub
19481 : type(xoshiro256ssw_type) , intent(inout) :: rng
19482 : end subroutine
19483 : #endif
19484 :
19485 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19486 :
19487 : #if RK5_ENABLED
19488 : PURE module subroutine setUnifRandRNGXLU_D3_RK5(rng, rand, lb, ub)
19489 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19490 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_RK5
19491 : #endif
19492 : use pm_kind, only: RKC => RK5
19493 : real(RKC) , intent(out) :: rand(:,:,:)
19494 : real(RKC) , intent(in) :: lb, ub
19495 : type(xoshiro256ssw_type) , intent(inout) :: rng
19496 : end subroutine
19497 : #endif
19498 :
19499 : #if RK4_ENABLED
19500 : PURE module subroutine setUnifRandRNGXLU_D3_RK4(rng, rand, lb, ub)
19501 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19502 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_RK4
19503 : #endif
19504 : use pm_kind, only: RKC => RK4
19505 : real(RKC) , intent(out) :: rand(:,:,:)
19506 : real(RKC) , intent(in) :: lb, ub
19507 : type(xoshiro256ssw_type) , intent(inout) :: rng
19508 : end subroutine
19509 : #endif
19510 :
19511 : #if RK3_ENABLED
19512 : PURE module subroutine setUnifRandRNGXLU_D3_RK3(rng, rand, lb, ub)
19513 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19514 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_RK3
19515 : #endif
19516 : use pm_kind, only: RKC => RK3
19517 : real(RKC) , intent(out) :: rand(:,:,:)
19518 : real(RKC) , intent(in) :: lb, ub
19519 : type(xoshiro256ssw_type) , intent(inout) :: rng
19520 : end subroutine
19521 : #endif
19522 :
19523 : #if RK2_ENABLED
19524 : PURE module subroutine setUnifRandRNGXLU_D3_RK2(rng, rand, lb, ub)
19525 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19526 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_RK2
19527 : #endif
19528 : use pm_kind, only: RKC => RK2
19529 : real(RKC) , intent(out) :: rand(:,:,:)
19530 : real(RKC) , intent(in) :: lb, ub
19531 : type(xoshiro256ssw_type) , intent(inout) :: rng
19532 : end subroutine
19533 : #endif
19534 :
19535 : #if RK1_ENABLED
19536 : PURE module subroutine setUnifRandRNGXLU_D3_RK1(rng, rand, lb, ub)
19537 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
19538 : !DEC$ ATTRIBUTES DLLEXPORT :: setUnifRandRNGXLU_D3_RK1
19539 : #endif
19540 : use pm_kind, only: RKC => RK1
19541 : real(RKC) , intent(out) :: rand(:,:,:)
19542 : real(RKC) , intent(in) :: lb, ub
19543 : type(xoshiro256ssw_type) , intent(inout) :: rng
19544 : end subroutine
19545 : #endif
19546 :
19547 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19548 :
19549 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19550 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19551 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19552 :
19553 : end interface
19554 :
19555 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
19556 :
19557 0 : end module pm_distUnif
|
