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 procedures and generic interfaces for obtaining the **Ordinal Ranking** of the elements of arrays of various types.
19 : !>
20 : !> \details
21 : !> Depending on the applications, the rank of the elements of an array can be defined in different ways:
22 : !>
23 : !> <ol>
24 : !>
25 : !> <li> <b>Ordinal ranking (`1234`) ranking:</b> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal) or [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
26 : !> This kind of ranking of values is widely known as ordinal (`1234`) ranking.<br>
27 : !> In ordinal ranking, all items receive distinct ordinal numbers, including items that compare equal.<br>
28 : !> The assignment of distinct ordinal numbers to items that compare equal can be done at random, or arbitrarily,
29 : !> but it is generally preferable to use a system that is arbitrary but consistent,
30 : !> as this gives stable results if the ranking is done multiple times.<br>
31 : !> In computer data processing, ordinal ranking is also referred to as <b>row numbering</b>.
32 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the <b>ordinal ranking</b> `1234`.<br>
33 : !>
34 : !> <li> <b>Standard competition (`1224`) ranking:</b> [getRankStandard](@ref pm_arrayRank::getRankStandard) or [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
35 : !> This kind of ranking of values is widely known as Standard Competition (`1224`) ranking.<br>
36 : !> In Standard Competition ranking, items that compare equal receive the same ranking number,
37 : !> and then a gap is left in the ranking numbers. The number of ranking numbers that are left out
38 : !> in this gap is one less than the number of items that compared equal.<br>
39 : !> Equivalently, the ranking number of each item is `1` plus the number of items ranked above it.<br>
40 : !> This ranking strategy is frequently adopted for competitions, as it means that if two (or more) competitors
41 : !> tie for a position in the ranking, and the position of all those ranked below them is unaffected
42 : !> (i.e., a competitor only comes second if exactly one person scores better than them,
43 : !> third if exactly two people score better than them, fourth if exactly three people score better than them, etc.).<br>
44 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number `1` (*first*),
45 : !> *B* gets ranking number `2` (*joint second*), *C* also gets ranking number `2` (*joint second*) and *D* gets ranking number `4` (*fourth*).<br>
46 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the Standard Competition ranking `1224`.<br>
47 : !>
48 : !> <li> <b>Modified competition (`1334`) ranking:</b> [getRankModified](@ref pm_arrayRank::getRankModified) or [setRankModified](@ref pm_arrayRank::setRankModified)<br>
49 : !> This kind of ranking of values is widely known as Modified Competition (`1334`) ranking.<br>
50 : !> Sometimes, competition ranking is done by leaving the gaps in the ranking numbers before the sets of equal-ranking items
51 : !> (rather than after them as in Standard Competition ranking).<br>
52 : !> The number of ranking numbers that are left out in this gap
53 : !> remains one less than the number of items that compared equal.<br>
54 : !> Equivalently, the ranking number of each item is equal to the number of items ranked equal to it or above it.<br>
55 : !> This ranking ensures that a competitor only comes second if they score higher than all but one of their opponents,
56 : !> third if they score higher than all but two of their opponents, etc.<br>
57 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked head of *D*, then *A* gets ranking
58 : !> number `1` (*first*), *B* gets ranking number `3` (*joint third*), *C* also gets ranking number `3` (*joint third*)
59 : !> and *D* gets ranking number `4` (*fourth*). In this case, nobody would get ranking number `2` (*second*) (left as a gap).<br>
60 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the Modified Competition ranking `1334`.<br>
61 : !>
62 : !> <li> <b>Dense (`1223`) ranking:</b> [getRankDense](@ref pm_arrayRank::getRankDense) or [setRankDense](@ref pm_arrayRank::setRankDense)<br>
63 : !> This kind of ranking of values is widely known as dense (`1223`) ranking.<br>
64 : !> In Dense ranking, items that compare equally receive the same ranking number, and the next items receive the immediately following ranking number.<br>
65 : !> Equivalently, the ranking number of each item is `1` plus the number of items ranked above it that are distinct with respect to the ranking order.<br>
66 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number 1 (*first*), *B* gets
67 : !> ranking number `2` (*joint second*), *C* also gets ranking number `2` (*joint second*) and *D* gets ranking number `3` (*Third*).<br>
68 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the Dense ranking `1223`.<br>
69 : !> Dense ranking effective factorizes the array into classes of unique values.<br>
70 : !> Therefore, the Dense rank of each element of the array is simply its class <b>level</b>.
71 : !>
72 : !> <li> <b>Fractional (`1 2.5 2.5 4`) ranking:</b> [getRankFractional](@ref pm_arrayRank::getRankFractional) or [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
73 : !> This kind of ranking of values is widely known as fractional (`1 2.5 2.5 4`) ranking.<br>
74 : !> In Fractional ranking, items that compare equal receive the same ranking number, which is the mean of what they would have under ordinal rankings;<br>
75 : !> Equivalently, the ranking number of 1 plus the number of items ranked above it plus half the number of items equal to it.<br>
76 : !> This strategy has the property that the sum of the ranking numbers is the same as under ordinal ranking.<br>
77 : !> For this reason, it is used in computing Borda counts and ranking statistics (e.g., Spearman Correlation).<br>
78 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number `1` (*first*),
79 : !> *B* and *C* each get ranking number `2.5` (average of *joint second/third*) and *D* gets ranking number `4` (*fourth*).<br>
80 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the Fractional ranking `1223`.<br>
81 : !> <b>Example:</b><br>
82 : !> Suppose the data set is `1.0, 1.0, 2.0, 3.0, 3.0, 4.0, 5.0, 5.0, 5.0`.<br>
83 : !> The ordinal ranks are `1, 2, 3, 4, 5, 6, 7, 8, 9`.<br>
84 : !> For `v = 1.0`, the Fractional rank is the average of the ordinal ranks: `(1 + 2) / 2 = 1.5`.<br>
85 : !> In a similar manner, for `v = 5.0`, the Fractional rank is `(7 + 8 + 9) / 3 = 8.0`.<br>
86 : !> Thus the Fractional ranks are: `1.5, 1.5, 3.0, 4.5, 4.5, 6.0, 8.0, 8.0, 8.0`<br>
87 : !>
88 : !> </ol>
89 : !>
90 : !> \warning
91 : !> The support for ranking of string containers is disabled when the library is built with
92 : !> the GNU Fortran compiler because of the lack of support for Parameterized Derived Types (PDTs) in gfortran.
93 : !>
94 : !> \note
95 : !> Obtaining the **ordinal ranking** of an array is very similar to obtaining the sorted indices of the array.<br>
96 : !> For more information see this [article](https://en.wikipedia.org/wiki/Ranking).<br>
97 : !>
98 : !> \todo
99 : !> \plow
100 : !> The relevant benchmarks comparing the functional and subroutine interfaces should be added here.<br>
101 : !>
102 : !> \todo
103 : !> \pvhigh
104 : !> Support for ranking of arrays of PDTs must be enabled again as soon as gfortran supports PDTs.<br>
105 : !>
106 : !> \todo
107 : !> \phigh
108 : !> An optional argument `sorted` must be added to all interfaces within this module to
109 : !> allow fast computation of the rankings of previously sorted arrays without redundant resorting.<br>
110 : !>
111 : !> \test
112 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)<br>
113 : !>
114 : !> \todo
115 : !> \pmed
116 : !> The generic interfaces of this module must be extended to support rankings of matrices along a specified dimension.<br>
117 : !> Such a pattern occurs, for example, in computing the [Spearman rank correlation matrix](@ref pm_sampleCor).<br>
118 : !>
119 : !> \todo
120 : !> \pmed
121 : !> The current implementation of the generic ranking interfaces of this module are separated from each other.<br>
122 : !> However, it may be preferrable to merge all generic interfaces into single interface bindings `getRank()` and `setRank()`.<br>
123 : !> Consequently, an extra argument of class [rank_type](@ref pm_arrayRank::rank_type) must be added to all procedure interfaces to make them distinguishable.<br>
124 : !> For now, the procedures for different ranking methods were are under separate generic interface names, because of the complexity in the merging of the
125 : !> fractional ranking procedures (which output `real` ranks of default kind \RK) with the rest (which output `integer` ranks of default kind \IK).<br>
126 : !>
127 : !> \finmain
128 : !>
129 : !> \author
130 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
131 :
132 : ! \copydetails pm_arrayRank
133 :
134 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
135 :
136 : module pm_arrayRank
137 :
138 : use pm_kind, only: SK, IK, LK
139 :
140 : implicit none
141 :
142 : character(*,SK), parameter :: MODULE_NAME = "@pm_arrayRank"
143 :
144 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
145 :
146 : !> \brief
147 : !> This is an `abstract` derived type for constructing concrete derived types to
148 : !> distinguish various procedure signatures that require different forms of array ranking (dense, fractional, modified, ordinal, standard, ...).<br>
149 : !>
150 : !> \details
151 : !> This `abstract` derived type is not meant to be directly accessed by the end users.<br>
152 : !> Instead, the end users must use `parameter` objects instantiated from the concrete subclasses of this parent `abstract` derived type.<br>
153 : !>
154 : !> \see
155 : !> [dense](@ref pm_arrayRank::dense)<br>
156 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
157 : !> [modified](@ref pm_arrayRank::modified)<br>
158 : !> [standard](@ref pm_arrayRank::standard)<br>
159 : !> [fractional](@ref pm_arrayRank::fractional)<br>
160 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
161 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
162 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
163 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
164 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
165 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
166 : !>
167 : !> \finmain{rank_type}
168 : !>
169 : !> \author
170 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
171 : type, abstract :: rank_type
172 : end type
173 :
174 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
175 :
176 : !> \brief
177 : !> This is a concrete derived type whose instances are exclusively used
178 : !> to request dense ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
179 : !>
180 : !> \details
181 : !> Objects instantiated from this derived type are exclusively used to differentiate
182 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
183 : !> As such, this concrete derived type does not contain any attributes.<br>
184 : !>
185 : !> \note
186 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
187 : !> Instead, the end users should use the specific object parameter instance of this derived type
188 : !> (e.g., [dense](@ref pm_arrayRank::dense)) as directed by the documentation of the specific procedure they intend to use.<br>
189 : !>
190 : !> \see
191 : !> [dense](@ref pm_arrayRank::dense)<br>
192 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
193 : !> [modified](@ref pm_arrayRank::modified)<br>
194 : !> [standard](@ref pm_arrayRank::standard)<br>
195 : !> [fractional](@ref pm_arrayRank::fractional)<br>
196 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
197 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
198 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
199 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
200 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
201 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
202 : !>
203 : !> \finmain{dense_type}
204 : !>
205 : !> \author
206 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
207 : type, extends(rank_type) :: dense_type
208 : end type
209 :
210 : !> \brief
211 : !> This is a scalar `parameter` object of type [dense_type](@ref pm_arrayRank::dense_type) that is exclusively used
212 : !> to request the dense ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
213 : !>
214 : !> \details
215 : !> For example usage, see the documentation of the target procedure requiring this object.<br>
216 : !>
217 : !> \see
218 : !> [dense](@ref pm_arrayRank::dense)<br>
219 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
220 : !> [modified](@ref pm_arrayRank::modified)<br>
221 : !> [standard](@ref pm_arrayRank::standard)<br>
222 : !> [fractional](@ref pm_arrayRank::fractional)<br>
223 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
224 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
225 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
226 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
227 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
228 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
229 : !>
230 : !> \finmain{dense}
231 : !>
232 : !> \author
233 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
234 : type(dense_type), parameter :: dense = dense_type()
235 :
236 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
237 :
238 : !> \brief
239 : !> This is a concrete derived type whose instances are exclusively used
240 : !> to request the ordinal ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
241 : !>
242 : !> \details
243 : !> Objects instantiated from this derived type are exclusively used to differentiate
244 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
245 : !> As such, this concrete derived type does not contain any attributes.<br>
246 : !>
247 : !> \note
248 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
249 : !> Instead, the end users should use the specific object parameter instance of this derived type
250 : !> (e.g., [ordinal](@ref pm_arrayRank::ordinal)) as directed by the documentation of the specific procedure they intend to use.<br>
251 : !>
252 : !> \see
253 : !> [dense](@ref pm_arrayRank::dense)<br>
254 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
255 : !> [modified](@ref pm_arrayRank::modified)<br>
256 : !> [standard](@ref pm_arrayRank::standard)<br>
257 : !> [fractional](@ref pm_arrayRank::fractional)<br>
258 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
259 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
260 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
261 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
262 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
263 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
264 : !>
265 : !> \finmain{ordinal_type}
266 : !>
267 : !> \author
268 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
269 : type, extends(rank_type) :: ordinal_type
270 : end type
271 :
272 : !> \brief
273 : !> This is a scalar `parameter` object of type [ordinal_type](@ref pm_arrayRank::ordinal_type) that is exclusively used
274 : !> to request the ordinal ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
275 : !>
276 : !> \details
277 : !> For example usage, see the documentation of the target procedure requiring this object.<br>
278 : !>
279 : !> \see
280 : !> [dense](@ref pm_arrayRank::dense)<br>
281 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
282 : !> [modified](@ref pm_arrayRank::modified)<br>
283 : !> [standard](@ref pm_arrayRank::standard)<br>
284 : !> [fractional](@ref pm_arrayRank::fractional)<br>
285 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
286 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
287 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
288 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
289 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
290 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
291 : !>
292 : !> \finmain{ordinal}
293 : !>
294 : !> \author
295 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
296 : type(ordinal_type), parameter :: ordinal = ordinal_type()
297 :
298 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
299 :
300 : !> \brief
301 : !> This is a concrete derived type whose instances are exclusively used
302 : !> to request the modified ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
303 : !>
304 : !> \details
305 : !> Objects instantiated from this derived type are exclusively used to differentiate
306 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
307 : !> As such, this concrete derived type does not contain any attributes.<br>
308 : !>
309 : !> \note
310 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
311 : !> Instead, the end users should use the specific object parameter instance of this derived type
312 : !> (e.g., [modified](@ref pm_arrayRank::modified)) as directed by the documentation of the specific procedure they intend to use.<br>
313 : !>
314 : !> \see
315 : !> [dense](@ref pm_arrayRank::dense)<br>
316 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
317 : !> [modified](@ref pm_arrayRank::modified)<br>
318 : !> [standard](@ref pm_arrayRank::standard)<br>
319 : !> [fractional](@ref pm_arrayRank::fractional)<br>
320 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
321 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
322 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
323 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
324 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
325 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
326 : !>
327 : !> \finmain{modified_type}
328 : !>
329 : !> \author
330 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
331 : type, extends(rank_type) :: modified_type
332 : end type
333 :
334 : !> \brief
335 : !> This is a scalar `parameter` object of type [modified_type](@ref pm_arrayRank::modified_type) that is exclusively used
336 : !> to request the modified ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
337 : !>
338 : !> \details
339 : !> For example usage, see the documentation of the target procedure requiring this object.<br>
340 : !>
341 : !> \see
342 : !> [dense](@ref pm_arrayRank::dense)<br>
343 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
344 : !> [modified](@ref pm_arrayRank::modified)<br>
345 : !> [standard](@ref pm_arrayRank::standard)<br>
346 : !> [fractional](@ref pm_arrayRank::fractional)<br>
347 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
348 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
349 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
350 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
351 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
352 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
353 : !>
354 : !> \finmain{modified}
355 : !>
356 : !> \author
357 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
358 : type(modified_type), parameter :: modified = modified_type()
359 :
360 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
361 :
362 : !> \brief
363 : !> This is a concrete derived type whose instances are exclusively used
364 : !> to request the standard ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
365 : !>
366 : !> \details
367 : !> Objects instantiated from this derived type are exclusively used to differentiate
368 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
369 : !> As such, this concrete derived type does not contain any attributes.<br>
370 : !>
371 : !> \note
372 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
373 : !> Instead, the end users should use the specific object parameter instance of this derived type
374 : !> (e.g., [standard](@ref pm_arrayRank::standard)) as directed by the documentation of the specific procedure they intend to use.<br>
375 : !>
376 : !> \see
377 : !> [dense](@ref pm_arrayRank::dense)<br>
378 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
379 : !> [modified](@ref pm_arrayRank::modified)<br>
380 : !> [standard](@ref pm_arrayRank::standard)<br>
381 : !> [fractional](@ref pm_arrayRank::fractional)<br>
382 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
383 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
384 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
385 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
386 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
387 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
388 : !>
389 : !> \finmain{standard_type}
390 : !>
391 : !> \author
392 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
393 : type, extends(rank_type) :: standard_type
394 : end type
395 :
396 : !> \brief
397 : !> This is a scalar `parameter` object of type [standard_type](@ref pm_arrayRank::standard_type) that is exclusively used
398 : !> to request the standard ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
399 : !>
400 : !> \details
401 : !> For example usage, see the documentation of the target procedure requiring this object.<br>
402 : !>
403 : !> \see
404 : !> [dense](@ref pm_arrayRank::dense)<br>
405 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
406 : !> [modified](@ref pm_arrayRank::modified)<br>
407 : !> [standard](@ref pm_arrayRank::standard)<br>
408 : !> [fractional](@ref pm_arrayRank::fractional)<br>
409 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
410 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
411 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
412 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
413 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
414 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
415 : !>
416 : !> \finmain{standard}
417 : !>
418 : !> \author
419 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
420 : type(standard_type), parameter :: standard = standard_type()
421 :
422 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
423 :
424 : !> \brief
425 : !> This is a concrete derived type whose instances are exclusively used
426 : !> to request the fractional ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
427 : !>
428 : !> \details
429 : !> Objects instantiated from this derived type are exclusively used to differentiate
430 : !> the procedures within the various generic interfaces of the ParaMonte library.<br>
431 : !> As such, this concrete derived type does not contain any attributes.<br>
432 : !>
433 : !> \note
434 : !> This concrete derived type is not meant to be directly accessed by the end users.<br>
435 : !> Instead, the end users should use the specific object parameter instance of this derived type
436 : !> (e.g., [fractional](@ref pm_arrayRank::fractional)) as directed by the documentation of the specific procedure they intend to use.<br>
437 : !>
438 : !> \see
439 : !> [dense](@ref pm_arrayRank::dense)<br>
440 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
441 : !> [modified](@ref pm_arrayRank::modified)<br>
442 : !> [standard](@ref pm_arrayRank::standard)<br>
443 : !> [fractional](@ref pm_arrayRank::fractional)<br>
444 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
445 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
446 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
447 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
448 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
449 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
450 : !>
451 : !> \finmain{fractional_type}
452 : !>
453 : !> \author
454 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
455 : type, extends(rank_type) :: fractional_type
456 : end type
457 :
458 : !> \brief
459 : !> This is a scalar `parameter` object of type [fractional_type](@ref pm_arrayRank::fractional_type) that is exclusively used
460 : !> to request the fractional ranking of a given array within an interface of a procedure of the ParaMonte library.<br>
461 : !>
462 : !> \details
463 : !> For example usage, see the documentation of the target procedure requiring this object.<br>
464 : !>
465 : !> \see
466 : !> [dense](@ref pm_arrayRank::dense)<br>
467 : !> [ordinal](@ref pm_arrayRank::ordinal)<br>
468 : !> [modified](@ref pm_arrayRank::modified)<br>
469 : !> [standard](@ref pm_arrayRank::standard)<br>
470 : !> [fractional](@ref pm_arrayRank::fractional)<br>
471 : !> [dense_type](@ref pm_arrayRank::dense_type)<br>
472 : !> [ordinal_type](@ref pm_arrayRank::ordinal_type)<br>
473 : !> [modified_type](@ref pm_arrayRank::modified_type)<br>
474 : !> [standard_type](@ref pm_arrayRank::standard_type)<br>
475 : !> [fractional_type](@ref pm_arrayRank::fractional_type)<br>
476 : !> [rank_type](@ref pm_arrayRank::rank_type)<br>
477 : !>
478 : !> \finmain{fractional}
479 : !>
480 : !> \author
481 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
482 : type(fractional_type), parameter :: fractional = fractional_type()
483 :
484 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
485 :
486 : !> \brief
487 : !> Generate and return the **Dense rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
488 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
489 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
490 : !>
491 : !> \details
492 : !> This kind of ranking of values is widely known as <b>dense (`1223`) ranking</b>.<br>
493 : !> In Dense ranking, items that compare equally receive the same ranking number, and the next items receive the immediately following ranking number.<br>
494 : !> Equivalently, the ranking number of each item is `1` plus the number of items ranked above it that are distinct with respect to the ranking order.<br>
495 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number 1 (*first*), *B* gets
496 : !> ranking number `2` (*joint second*), *C* also gets ranking number `2` (*joint second*) and *D* gets ranking number `3` (*Third*).<br>
497 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Dense ranking** `1223`.<br>
498 : !> Dense ranking effective factorizes the array into classes of unique values.<br>
499 : !> Therefore, the Dense rank of each element of the array is simply its class **level**.<br>
500 : !>
501 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
502 : !> <ol>
503 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
504 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
505 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
506 : !> <li> type `integer` of kind \IKALL or,<br>
507 : !> <li> type `logical` of kind \LKALL or,<br>
508 : !> <li> type `complex` of kind \CKALL or,<br>
509 : !> <li> type `real` of kind \RKALL,<br>
510 : !> </ol>
511 : !> or,
512 : !> <ol>
513 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
514 : !> </ol>
515 : !> whose elements rankings will be computed and returned.
516 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type and kind as the input `array`.<br>
517 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
518 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
519 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
520 : !> If `array` is a Fortran string (i.e., a scalar `character`),
521 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
522 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
523 : !> \code{.F90}
524 : !> function isSorted(a,b) result (sorted)
525 : !> use pm_kind, only: SK, IK, LK, CK, RK
526 : !> TYPE(KIND) , intent(in) :: a, b
527 : !> logical(LK) :: sorted
528 : !> end function
529 : !> \endcode
530 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
531 : !> \code{.F90}
532 : !> use pm_container, only: StrCon
533 : !> use pm_kind, only: SK, IK, LK, CK, RK
534 : !> character(*, SK), intent(in) :: a, b
535 : !> integer(IK) , intent(in) :: a, b
536 : !> logical(LK) , intent(in) :: a, b
537 : !> complex(CK) , intent(in) :: a, b
538 : !> real(RK) , intent(in) :: a, b
539 : !> type(StrCon) , intent(in) :: a, b
540 : !> \endcode
541 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
542 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
543 : !> \code{.F90}
544 : !> function isSorted(a,b) result (sorted)
545 : !> character(1,SKC), intent(in) :: a, b
546 : !> logical(LK) :: sorted
547 : !> end function
548 : !> \endcode
549 : !> where `SKC` represents the kind of the input string argument `array`.<br>
550 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
551 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
552 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
553 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
554 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
555 : !>
556 : !> \return
557 : !> `rank(1:size(array)` : The output `contiguous` array of rank `1` of type `integer` of default kind \IK containing the ranks of the corresponding elements of `array`.<br>
558 : !> The size of `rank` matches that of `array` (or its length type parameter if `array` is a scalar string).<br>
559 : !> **Read `rank(i)` as the Dense rank of the `i`th element of `array`.**
560 : !>
561 : !> \interface{getRankDense}
562 : !> \code{.F90}
563 : !>
564 : !> use pm_arrayRank, only: getRankDense
565 : !>
566 : !> rank(1:size(array)) = getRankDense(array)
567 : !> rank(1:size(array)) = getRankDense(array, isSorted)
568 : !>
569 : !> \endcode
570 : !>
571 : !> \warning
572 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
573 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
574 : !> identify ties within the Standard ranking of the input `array`.
575 : !>
576 : !> \warnpure
577 : !>
578 : !> \warning
579 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
580 : !>
581 : !> \see
582 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
583 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
584 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
585 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
586 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
587 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
588 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
589 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
590 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
591 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
592 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
593 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
594 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
595 : !>
596 : !> \example{getRankDense}
597 : !> \include{lineno} example/pm_arrayRank/getRankDense/main.F90
598 : !> \compilef{getRankDense}
599 : !> \output{getRankDense}
600 : !> \include{lineno} example/pm_arrayRank/getRankDense/main.out.F90
601 : !>
602 : !> \test
603 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
604 : !>
605 : !> \bug
606 : !> \status \unresolved
607 : !> \source \ifort{2021.5}
608 : !> \desc
609 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
610 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
611 : !> \remedy
612 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
613 : !>
614 : !> \todo
615 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
616 : !>
617 : !> \todo
618 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
619 : !>
620 : !> \finmain{getRankDense}
621 : !>
622 : !> \author
623 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
624 : interface getRankDense
625 :
626 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
627 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
628 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
629 :
630 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
631 :
632 : #if SK5_ENABLED
633 : module function getRankDenseDefCom_D0_SK5(array) result(rank)
634 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
635 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D0_SK5
636 : #endif
637 : use pm_kind, only: TKR => IK, SKC => SK5
638 : character(*,SKC) , intent(in) :: array
639 : integer(TKR) :: rank(len(array, IK))
640 : end function
641 : #endif
642 :
643 : #if SK4_ENABLED
644 : module function getRankDenseDefCom_D0_SK4(array) result(rank)
645 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
646 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D0_SK4
647 : #endif
648 : use pm_kind, only: TKR => IK, SKC => SK4
649 : character(*,SKC) , intent(in) :: array
650 : integer(TKR) :: rank(len(array, IK))
651 : end function
652 : #endif
653 :
654 : #if SK3_ENABLED
655 : module function getRankDenseDefCom_D0_SK3(array) result(rank)
656 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
657 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D0_SK3
658 : #endif
659 : use pm_kind, only: TKR => IK, SKC => SK3
660 : character(*,SKC) , intent(in) :: array
661 : integer(TKR) :: rank(len(array, IK))
662 : end function
663 : #endif
664 :
665 : #if SK2_ENABLED
666 : module function getRankDenseDefCom_D0_SK2(array) result(rank)
667 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
668 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D0_SK2
669 : #endif
670 : use pm_kind, only: TKR => IK, SKC => SK2
671 : character(*,SKC) , intent(in) :: array
672 : integer(TKR) :: rank(len(array, IK))
673 : end function
674 : #endif
675 :
676 : #if SK1_ENABLED
677 : module function getRankDenseDefCom_D0_SK1(array) result(rank)
678 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
679 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D0_SK1
680 : #endif
681 : use pm_kind, only: TKR => IK, SKC => SK1
682 : character(*,SKC) , intent(in) :: array
683 : integer(TKR) :: rank(len(array, IK))
684 : end function
685 : #endif
686 :
687 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
688 :
689 : #if SK5_ENABLED
690 : module function getRankDenseDefCom_D1_SK5(array) result(rank)
691 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
692 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_SK5
693 : #endif
694 : use pm_kind, only: TKR => IK, SKC => SK5
695 : character(*,SKC) , intent(in) , contiguous :: array(:)
696 : integer(TKR) :: rank(size(array, kind = IK))
697 : end function
698 : #endif
699 :
700 : #if SK4_ENABLED
701 : module function getRankDenseDefCom_D1_SK4(array) result(rank)
702 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
703 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_SK4
704 : #endif
705 : use pm_kind, only: TKR => IK, SKC => SK4
706 : character(*,SKC) , intent(in) , contiguous :: array(:)
707 : integer(TKR) :: rank(size(array, kind = IK))
708 : end function
709 : #endif
710 :
711 : #if SK3_ENABLED
712 : module function getRankDenseDefCom_D1_SK3(array) result(rank)
713 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
714 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_SK3
715 : #endif
716 : use pm_kind, only: TKR => IK, SKC => SK3
717 : character(*,SKC) , intent(in) , contiguous :: array(:)
718 : integer(TKR) :: rank(size(array, kind = IK))
719 : end function
720 : #endif
721 :
722 : #if SK2_ENABLED
723 : module function getRankDenseDefCom_D1_SK2(array) result(rank)
724 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
725 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_SK2
726 : #endif
727 : use pm_kind, only: TKR => IK, SKC => SK2
728 : character(*,SKC) , intent(in) , contiguous :: array(:)
729 : integer(TKR) :: rank(size(array, kind = IK))
730 : end function
731 : #endif
732 :
733 : #if SK1_ENABLED
734 : module function getRankDenseDefCom_D1_SK1(array) result(rank)
735 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
736 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_SK1
737 : #endif
738 : use pm_kind, only: TKR => IK, SKC => SK1
739 : character(*,SKC) , intent(in) , contiguous :: array(:)
740 : integer(TKR) :: rank(size(array, kind = IK))
741 : end function
742 : #endif
743 :
744 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
745 :
746 : #if IK5_ENABLED
747 : module function getRankDenseDefCom_D1_IK5(array) result(rank)
748 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
749 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_IK5
750 : #endif
751 : use pm_kind, only: TKR => IK, IKC => IK5
752 : integer(IKC) , intent(in) , contiguous :: array(:)
753 : integer(TKR) :: rank(size(array, kind = IK))
754 : end function
755 : #endif
756 :
757 : #if IK4_ENABLED
758 : module function getRankDenseDefCom_D1_IK4(array) result(rank)
759 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
760 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_IK4
761 : #endif
762 : use pm_kind, only: TKR => IK, IKC => IK4
763 : integer(IKC) , intent(in) , contiguous :: array(:)
764 : integer(TKR) :: rank(size(array, kind = IK))
765 : end function
766 : #endif
767 :
768 : #if IK3_ENABLED
769 : module function getRankDenseDefCom_D1_IK3(array) result(rank)
770 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
771 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_IK3
772 : #endif
773 : use pm_kind, only: TKR => IK, IKC => IK3
774 : integer(IKC) , intent(in) , contiguous :: array(:)
775 : integer(TKR) :: rank(size(array, kind = IK))
776 : end function
777 : #endif
778 :
779 : #if IK2_ENABLED
780 : module function getRankDenseDefCom_D1_IK2(array) result(rank)
781 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
782 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_IK2
783 : #endif
784 : use pm_kind, only: TKR => IK, IKC => IK2
785 : integer(IKC) , intent(in) , contiguous :: array(:)
786 : integer(TKR) :: rank(size(array, kind = IK))
787 : end function
788 : #endif
789 :
790 : #if IK1_ENABLED
791 : module function getRankDenseDefCom_D1_IK1(array) result(rank)
792 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
793 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_IK1
794 : #endif
795 : use pm_kind, only: TKR => IK, IKC => IK1
796 : integer(IKC) , intent(in) , contiguous :: array(:)
797 : integer(TKR) :: rank(size(array, kind = IK))
798 : end function
799 : #endif
800 :
801 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
802 :
803 : #if LK5_ENABLED
804 : module function getRankDenseDefCom_D1_LK5(array) result(rank)
805 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
806 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_LK5
807 : #endif
808 : use pm_kind, only: TKR => IK, LKC => LK5
809 : logical(LKC) , intent(in) , contiguous :: array(:)
810 : integer(TKR) :: rank(size(array, kind = IK))
811 : end function
812 : #endif
813 :
814 : #if LK4_ENABLED
815 : module function getRankDenseDefCom_D1_LK4(array) result(rank)
816 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
817 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_LK4
818 : #endif
819 : use pm_kind, only: TKR => IK, LKC => LK4
820 : logical(LKC) , intent(in) , contiguous :: array(:)
821 : integer(TKR) :: rank(size(array, kind = IK))
822 : end function
823 : #endif
824 :
825 : #if LK3_ENABLED
826 : module function getRankDenseDefCom_D1_LK3(array) result(rank)
827 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
828 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_LK3
829 : #endif
830 : use pm_kind, only: TKR => IK, LKC => LK3
831 : logical(LKC) , intent(in) , contiguous :: array(:)
832 : integer(TKR) :: rank(size(array, kind = IK))
833 : end function
834 : #endif
835 :
836 : #if LK2_ENABLED
837 : module function getRankDenseDefCom_D1_LK2(array) result(rank)
838 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
839 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_LK2
840 : #endif
841 : use pm_kind, only: TKR => IK, LKC => LK2
842 : logical(LKC) , intent(in) , contiguous :: array(:)
843 : integer(TKR) :: rank(size(array, kind = IK))
844 : end function
845 : #endif
846 :
847 : #if LK1_ENABLED
848 : module function getRankDenseDefCom_D1_LK1(array) result(rank)
849 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
850 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_LK1
851 : #endif
852 : use pm_kind, only: TKR => IK, LKC => LK1
853 : logical(LKC) , intent(in) , contiguous :: array(:)
854 : integer(TKR) :: rank(size(array, kind = IK))
855 : end function
856 : #endif
857 :
858 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
859 :
860 : #if CK5_ENABLED
861 : module function getRankDenseDefCom_D1_CK5(array) result(rank)
862 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
863 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_CK5
864 : #endif
865 : use pm_kind, only: TKR => IK, CKC => CK5
866 : complex(CKC) , intent(in) , contiguous :: array(:)
867 : integer(TKR) :: rank(size(array, kind = IK))
868 : end function
869 : #endif
870 :
871 : #if CK4_ENABLED
872 : module function getRankDenseDefCom_D1_CK4(array) result(rank)
873 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
874 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_CK4
875 : #endif
876 : use pm_kind, only: TKR => IK, CKC => CK4
877 : complex(CKC) , intent(in) , contiguous :: array(:)
878 : integer(TKR) :: rank(size(array, kind = IK))
879 : end function
880 : #endif
881 :
882 : #if CK3_ENABLED
883 : module function getRankDenseDefCom_D1_CK3(array) result(rank)
884 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
885 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_CK3
886 : #endif
887 : use pm_kind, only: TKR => IK, CKC => CK3
888 : complex(CKC) , intent(in) , contiguous :: array(:)
889 : integer(TKR) :: rank(size(array, kind = IK))
890 : end function
891 : #endif
892 :
893 : #if CK2_ENABLED
894 : module function getRankDenseDefCom_D1_CK2(array) result(rank)
895 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
896 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_CK2
897 : #endif
898 : use pm_kind, only: TKR => IK, CKC => CK2
899 : complex(CKC) , intent(in) , contiguous :: array(:)
900 : integer(TKR) :: rank(size(array, kind = IK))
901 : end function
902 : #endif
903 :
904 : #if CK1_ENABLED
905 : module function getRankDenseDefCom_D1_CK1(array) result(rank)
906 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
907 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_CK1
908 : #endif
909 : use pm_kind, only: TKR => IK, CKC => CK1
910 : complex(CKC) , intent(in) , contiguous :: array(:)
911 : integer(TKR) :: rank(size(array, kind = IK))
912 : end function
913 : #endif
914 :
915 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
916 :
917 : #if RK5_ENABLED
918 : module function getRankDenseDefCom_D1_RK5(array) result(rank)
919 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
920 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_RK5
921 : #endif
922 : use pm_kind, only: TKR => IK, RKC => RK5
923 : real(RKC) , intent(in) , contiguous :: array(:)
924 : integer(TKR) :: rank(size(array, kind = IK))
925 : end function
926 : #endif
927 :
928 : #if RK4_ENABLED
929 : module function getRankDenseDefCom_D1_RK4(array) result(rank)
930 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
931 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_RK4
932 : #endif
933 : use pm_kind, only: TKR => IK, RKC => RK4
934 : real(RKC) , intent(in) , contiguous :: array(:)
935 : integer(TKR) :: rank(size(array, kind = IK))
936 : end function
937 : #endif
938 :
939 : #if RK3_ENABLED
940 : module function getRankDenseDefCom_D1_RK3(array) result(rank)
941 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
942 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_RK3
943 : #endif
944 : use pm_kind, only: TKR => IK, RKC => RK3
945 : real(RKC) , intent(in) , contiguous :: array(:)
946 : integer(TKR) :: rank(size(array, kind = IK))
947 : end function
948 : #endif
949 :
950 : #if RK2_ENABLED
951 : module function getRankDenseDefCom_D1_RK2(array) result(rank)
952 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
953 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_RK2
954 : #endif
955 : use pm_kind, only: TKR => IK, RKC => RK2
956 : real(RKC) , intent(in) , contiguous :: array(:)
957 : integer(TKR) :: rank(size(array, kind = IK))
958 : end function
959 : #endif
960 :
961 : #if RK1_ENABLED
962 : module function getRankDenseDefCom_D1_RK1(array) result(rank)
963 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
964 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_RK1
965 : #endif
966 : use pm_kind, only: TKR => IK, RKC => RK1
967 : real(RKC) , intent(in) , contiguous :: array(:)
968 : integer(TKR) :: rank(size(array, kind = IK))
969 : end function
970 : #endif
971 :
972 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
973 :
974 : #if SK5_ENABLED
975 : module function getRankDenseDefCom_D1_PSSK5(array) result(rank)
976 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
977 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_PSSK5
978 : #endif
979 : use pm_kind, only: TKR => IK, SKC => SK5
980 : use pm_container, only: css_pdt
981 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
982 : integer(TKR) :: rank(size(array, kind = IK))
983 : end function
984 : #endif
985 :
986 : #if SK4_ENABLED
987 : module function getRankDenseDefCom_D1_PSSK4(array) result(rank)
988 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
989 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_PSSK4
990 : #endif
991 : use pm_kind, only: TKR => IK, SKC => SK4
992 : use pm_container, only: css_pdt
993 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
994 : integer(TKR) :: rank(size(array, kind = IK))
995 : end function
996 : #endif
997 :
998 : #if SK3_ENABLED
999 : module function getRankDenseDefCom_D1_PSSK3(array) result(rank)
1000 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1001 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_PSSK3
1002 : #endif
1003 : use pm_kind, only: TKR => IK, SKC => SK3
1004 : use pm_container, only: css_pdt
1005 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1006 : integer(TKR) :: rank(size(array, kind = IK))
1007 : end function
1008 : #endif
1009 :
1010 : #if SK2_ENABLED
1011 : module function getRankDenseDefCom_D1_PSSK2(array) result(rank)
1012 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1013 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_PSSK2
1014 : #endif
1015 : use pm_kind, only: TKR => IK, SKC => SK2
1016 : use pm_container, only: css_pdt
1017 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1018 : integer(TKR) :: rank(size(array, kind = IK))
1019 : end function
1020 : #endif
1021 :
1022 : #if SK1_ENABLED
1023 : module function getRankDenseDefCom_D1_PSSK1(array) result(rank)
1024 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1025 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_PSSK1
1026 : #endif
1027 : use pm_kind, only: TKR => IK, SKC => SK1
1028 : use pm_container, only: css_pdt
1029 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1030 : integer(TKR) :: rank(size(array, kind = IK))
1031 : end function
1032 : #endif
1033 :
1034 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1035 :
1036 : module function getRankDenseDefCom_D1_BSSK(array) result(rank)
1037 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1038 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseDefCom_D1_BSSK
1039 : #endif
1040 : use pm_kind, only: TKR => IK, SKC => SK
1041 : use pm_container, only: css_type
1042 : type(css_type) , intent(in) , contiguous :: array(:)
1043 : integer(TKR) :: rank(size(array, kind = IK))
1044 : end function
1045 :
1046 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1047 :
1048 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1049 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1050 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1051 :
1052 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1053 :
1054 : #if SK5_ENABLED
1055 : module function getRankDenseCusCom_D0_SK5(array, isSorted) result(rank)
1056 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1057 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D0_SK5
1058 : #endif
1059 : use pm_kind, only: TKR => IK, SKC => SK5
1060 : character(*,SKC) , intent(in) :: array
1061 : procedure(logical(LK)) :: isSorted
1062 : integer(TKR) :: rank(len(array, IK))
1063 : end function
1064 : #endif
1065 :
1066 : #if SK4_ENABLED
1067 : module function getRankDenseCusCom_D0_SK4(array, isSorted) result(rank)
1068 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1069 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D0_SK4
1070 : #endif
1071 : use pm_kind, only: TKR => IK, SKC => SK4
1072 : character(*,SKC) , intent(in) :: array
1073 : procedure(logical(LK)) :: isSorted
1074 : integer(TKR) :: rank(len(array, IK))
1075 : end function
1076 : #endif
1077 :
1078 : #if SK3_ENABLED
1079 : module function getRankDenseCusCom_D0_SK3(array, isSorted) result(rank)
1080 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1081 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D0_SK3
1082 : #endif
1083 : use pm_kind, only: TKR => IK, SKC => SK3
1084 : character(*,SKC) , intent(in) :: array
1085 : procedure(logical(LK)) :: isSorted
1086 : integer(TKR) :: rank(len(array, IK))
1087 : end function
1088 : #endif
1089 :
1090 : #if SK2_ENABLED
1091 : module function getRankDenseCusCom_D0_SK2(array, isSorted) result(rank)
1092 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1093 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D0_SK2
1094 : #endif
1095 : use pm_kind, only: TKR => IK, SKC => SK2
1096 : character(*,SKC) , intent(in) :: array
1097 : procedure(logical(LK)) :: isSorted
1098 : integer(TKR) :: rank(len(array, IK))
1099 : end function
1100 : #endif
1101 :
1102 : #if SK1_ENABLED
1103 : module function getRankDenseCusCom_D0_SK1(array, isSorted) result(rank)
1104 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1105 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D0_SK1
1106 : #endif
1107 : use pm_kind, only: TKR => IK, SKC => SK1
1108 : character(*,SKC) , intent(in) :: array
1109 : procedure(logical(LK)) :: isSorted
1110 : integer(TKR) :: rank(len(array, IK))
1111 : end function
1112 : #endif
1113 :
1114 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1115 :
1116 : #if SK5_ENABLED
1117 : module function getRankDenseCusCom_D1_SK5(array, isSorted) result(rank)
1118 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1119 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_SK5
1120 : #endif
1121 : use pm_kind, only: TKR => IK, SKC => SK5
1122 : character(*,SKC) , intent(in) , contiguous :: array(:)
1123 : procedure(logical(LK)) :: isSorted
1124 : integer(TKR) :: rank(size(array, kind = IK))
1125 : end function
1126 : #endif
1127 :
1128 : #if SK4_ENABLED
1129 : module function getRankDenseCusCom_D1_SK4(array, isSorted) result(rank)
1130 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1131 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_SK4
1132 : #endif
1133 : use pm_kind, only: TKR => IK, SKC => SK4
1134 : character(*,SKC) , intent(in) , contiguous :: array(:)
1135 : procedure(logical(LK)) :: isSorted
1136 : integer(TKR) :: rank(size(array, kind = IK))
1137 : end function
1138 : #endif
1139 :
1140 : #if SK3_ENABLED
1141 : module function getRankDenseCusCom_D1_SK3(array, isSorted) result(rank)
1142 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1143 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_SK3
1144 : #endif
1145 : use pm_kind, only: TKR => IK, SKC => SK3
1146 : character(*,SKC) , intent(in) , contiguous :: array(:)
1147 : procedure(logical(LK)) :: isSorted
1148 : integer(TKR) :: rank(size(array, kind = IK))
1149 : end function
1150 : #endif
1151 :
1152 : #if SK2_ENABLED
1153 : module function getRankDenseCusCom_D1_SK2(array, isSorted) result(rank)
1154 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1155 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_SK2
1156 : #endif
1157 : use pm_kind, only: TKR => IK, SKC => SK2
1158 : character(*,SKC) , intent(in) , contiguous :: array(:)
1159 : procedure(logical(LK)) :: isSorted
1160 : integer(TKR) :: rank(size(array, kind = IK))
1161 : end function
1162 : #endif
1163 :
1164 : #if SK1_ENABLED
1165 : module function getRankDenseCusCom_D1_SK1(array, isSorted) result(rank)
1166 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1167 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_SK1
1168 : #endif
1169 : use pm_kind, only: TKR => IK, SKC => SK1
1170 : character(*,SKC) , intent(in) , contiguous :: array(:)
1171 : procedure(logical(LK)) :: isSorted
1172 : integer(TKR) :: rank(size(array, kind = IK))
1173 : end function
1174 : #endif
1175 :
1176 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1177 :
1178 : #if IK5_ENABLED
1179 : module function getRankDenseCusCom_D1_IK5(array, isSorted) result(rank)
1180 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1181 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_IK5
1182 : #endif
1183 : use pm_kind, only: TKR => IK, IKC => IK5
1184 : integer(IKC) , intent(in) , contiguous :: array(:)
1185 : procedure(logical(LK)) :: isSorted
1186 : integer(TKR) :: rank(size(array, kind = IK))
1187 : end function
1188 : #endif
1189 :
1190 : #if IK4_ENABLED
1191 : module function getRankDenseCusCom_D1_IK4(array, isSorted) result(rank)
1192 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1193 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_IK4
1194 : #endif
1195 : use pm_kind, only: TKR => IK, IKC => IK4
1196 : integer(IKC) , intent(in) , contiguous :: array(:)
1197 : procedure(logical(LK)) :: isSorted
1198 : integer(TKR) :: rank(size(array, kind = IK))
1199 : end function
1200 : #endif
1201 :
1202 : #if IK3_ENABLED
1203 : module function getRankDenseCusCom_D1_IK3(array, isSorted) result(rank)
1204 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1205 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_IK3
1206 : #endif
1207 : use pm_kind, only: TKR => IK, IKC => IK3
1208 : integer(IKC) , intent(in) , contiguous :: array(:)
1209 : procedure(logical(LK)) :: isSorted
1210 : integer(TKR) :: rank(size(array, kind = IK))
1211 : end function
1212 : #endif
1213 :
1214 : #if IK2_ENABLED
1215 : module function getRankDenseCusCom_D1_IK2(array, isSorted) result(rank)
1216 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1217 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_IK2
1218 : #endif
1219 : use pm_kind, only: TKR => IK, IKC => IK2
1220 : integer(IKC) , intent(in) , contiguous :: array(:)
1221 : procedure(logical(LK)) :: isSorted
1222 : integer(TKR) :: rank(size(array, kind = IK))
1223 : end function
1224 : #endif
1225 :
1226 : #if IK1_ENABLED
1227 : module function getRankDenseCusCom_D1_IK1(array, isSorted) result(rank)
1228 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1229 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_IK1
1230 : #endif
1231 : use pm_kind, only: TKR => IK, IKC => IK1
1232 : integer(IKC) , intent(in) , contiguous :: array(:)
1233 : procedure(logical(LK)) :: isSorted
1234 : integer(TKR) :: rank(size(array, kind = IK))
1235 : end function
1236 : #endif
1237 :
1238 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1239 :
1240 : #if LK5_ENABLED
1241 : module function getRankDenseCusCom_D1_LK5(array, isSorted) result(rank)
1242 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1243 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_LK5
1244 : #endif
1245 : use pm_kind, only: TKR => IK, LKC => LK5
1246 : logical(LKC) , intent(in) , contiguous :: array(:)
1247 : procedure(logical(LK)) :: isSorted
1248 : integer(TKR) :: rank(size(array, kind = IK))
1249 : end function
1250 : #endif
1251 :
1252 : #if LK4_ENABLED
1253 : module function getRankDenseCusCom_D1_LK4(array, isSorted) result(rank)
1254 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1255 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_LK4
1256 : #endif
1257 : use pm_kind, only: TKR => IK, LKC => LK4
1258 : logical(LKC) , intent(in) , contiguous :: array(:)
1259 : procedure(logical(LK)) :: isSorted
1260 : integer(TKR) :: rank(size(array, kind = IK))
1261 : end function
1262 : #endif
1263 :
1264 : #if LK3_ENABLED
1265 : module function getRankDenseCusCom_D1_LK3(array, isSorted) result(rank)
1266 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1267 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_LK3
1268 : #endif
1269 : use pm_kind, only: TKR => IK, LKC => LK3
1270 : logical(LKC) , intent(in) , contiguous :: array(:)
1271 : procedure(logical(LK)) :: isSorted
1272 : integer(TKR) :: rank(size(array, kind = IK))
1273 : end function
1274 : #endif
1275 :
1276 : #if LK2_ENABLED
1277 : module function getRankDenseCusCom_D1_LK2(array, isSorted) result(rank)
1278 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1279 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_LK2
1280 : #endif
1281 : use pm_kind, only: TKR => IK, LKC => LK2
1282 : logical(LKC) , intent(in) , contiguous :: array(:)
1283 : procedure(logical(LK)) :: isSorted
1284 : integer(TKR) :: rank(size(array, kind = IK))
1285 : end function
1286 : #endif
1287 :
1288 : #if LK1_ENABLED
1289 : module function getRankDenseCusCom_D1_LK1(array, isSorted) result(rank)
1290 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1291 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_LK1
1292 : #endif
1293 : use pm_kind, only: TKR => IK, LKC => LK1
1294 : logical(LKC) , intent(in) , contiguous :: array(:)
1295 : procedure(logical(LK)) :: isSorted
1296 : integer(TKR) :: rank(size(array, kind = IK))
1297 : end function
1298 : #endif
1299 :
1300 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1301 :
1302 : #if CK5_ENABLED
1303 : module function getRankDenseCusCom_D1_CK5(array, isSorted) result(rank)
1304 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1305 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_CK5
1306 : #endif
1307 : use pm_kind, only: TKR => IK, CKC => CK5
1308 : complex(CKC) , intent(in) , contiguous :: array(:)
1309 : procedure(logical(LK)) :: isSorted
1310 : integer(TKR) :: rank(size(array, kind = IK))
1311 : end function
1312 : #endif
1313 :
1314 : #if CK4_ENABLED
1315 : module function getRankDenseCusCom_D1_CK4(array, isSorted) result(rank)
1316 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1317 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_CK4
1318 : #endif
1319 : use pm_kind, only: TKR => IK, CKC => CK4
1320 : complex(CKC) , intent(in) , contiguous :: array(:)
1321 : procedure(logical(LK)) :: isSorted
1322 : integer(TKR) :: rank(size(array, kind = IK))
1323 : end function
1324 : #endif
1325 :
1326 : #if CK3_ENABLED
1327 : module function getRankDenseCusCom_D1_CK3(array, isSorted) result(rank)
1328 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1329 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_CK3
1330 : #endif
1331 : use pm_kind, only: TKR => IK, CKC => CK3
1332 : complex(CKC) , intent(in) , contiguous :: array(:)
1333 : procedure(logical(LK)) :: isSorted
1334 : integer(TKR) :: rank(size(array, kind = IK))
1335 : end function
1336 : #endif
1337 :
1338 : #if CK2_ENABLED
1339 : module function getRankDenseCusCom_D1_CK2(array, isSorted) result(rank)
1340 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1341 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_CK2
1342 : #endif
1343 : use pm_kind, only: TKR => IK, CKC => CK2
1344 : complex(CKC) , intent(in) , contiguous :: array(:)
1345 : procedure(logical(LK)) :: isSorted
1346 : integer(TKR) :: rank(size(array, kind = IK))
1347 : end function
1348 : #endif
1349 :
1350 : #if CK1_ENABLED
1351 : module function getRankDenseCusCom_D1_CK1(array, isSorted) result(rank)
1352 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1353 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_CK1
1354 : #endif
1355 : use pm_kind, only: TKR => IK, CKC => CK1
1356 : complex(CKC) , intent(in) , contiguous :: array(:)
1357 : procedure(logical(LK)) :: isSorted
1358 : integer(TKR) :: rank(size(array, kind = IK))
1359 : end function
1360 : #endif
1361 :
1362 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1363 :
1364 : #if RK5_ENABLED
1365 : module function getRankDenseCusCom_D1_RK5(array, isSorted) result(rank)
1366 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1367 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_RK5
1368 : #endif
1369 : use pm_kind, only: TKR => IK, RKC => RK5
1370 : real(RKC) , intent(in) , contiguous :: array(:)
1371 : procedure(logical(LK)) :: isSorted
1372 : integer(TKR) :: rank(size(array, kind = IK))
1373 : end function
1374 : #endif
1375 :
1376 : #if RK4_ENABLED
1377 : module function getRankDenseCusCom_D1_RK4(array, isSorted) result(rank)
1378 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1379 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_RK4
1380 : #endif
1381 : use pm_kind, only: TKR => IK, RKC => RK4
1382 : real(RKC) , intent(in) , contiguous :: array(:)
1383 : procedure(logical(LK)) :: isSorted
1384 : integer(TKR) :: rank(size(array, kind = IK))
1385 : end function
1386 : #endif
1387 :
1388 : #if RK3_ENABLED
1389 : module function getRankDenseCusCom_D1_RK3(array, isSorted) result(rank)
1390 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1391 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_RK3
1392 : #endif
1393 : use pm_kind, only: TKR => IK, RKC => RK3
1394 : real(RKC) , intent(in) , contiguous :: array(:)
1395 : procedure(logical(LK)) :: isSorted
1396 : integer(TKR) :: rank(size(array, kind = IK))
1397 : end function
1398 : #endif
1399 :
1400 : #if RK2_ENABLED
1401 : module function getRankDenseCusCom_D1_RK2(array, isSorted) result(rank)
1402 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1403 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_RK2
1404 : #endif
1405 : use pm_kind, only: TKR => IK, RKC => RK2
1406 : real(RKC) , intent(in) , contiguous :: array(:)
1407 : procedure(logical(LK)) :: isSorted
1408 : integer(TKR) :: rank(size(array, kind = IK))
1409 : end function
1410 : #endif
1411 :
1412 : #if RK1_ENABLED
1413 : module function getRankDenseCusCom_D1_RK1(array, isSorted) result(rank)
1414 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1415 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_RK1
1416 : #endif
1417 : use pm_kind, only: TKR => IK, RKC => RK1
1418 : real(RKC) , intent(in) , contiguous :: array(:)
1419 : procedure(logical(LK)) :: isSorted
1420 : integer(TKR) :: rank(size(array, kind = IK))
1421 : end function
1422 : #endif
1423 :
1424 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1425 :
1426 : #if SK5_ENABLED
1427 : module function getRankDenseCusCom_D1_PSSK5(array, isSorted) result(rank)
1428 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1429 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_PSSK5
1430 : #endif
1431 : use pm_kind, only: TKR => IK, SKC => SK5
1432 : use pm_container, only: css_pdt
1433 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1434 : procedure(logical(LK)) :: isSorted
1435 : integer(TKR) :: rank(size(array, kind = IK))
1436 : end function
1437 : #endif
1438 :
1439 : #if SK4_ENABLED
1440 : module function getRankDenseCusCom_D1_PSSK4(array, isSorted) result(rank)
1441 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1442 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_PSSK4
1443 : #endif
1444 : use pm_kind, only: TKR => IK, SKC => SK4
1445 : use pm_container, only: css_pdt
1446 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1447 : procedure(logical(LK)) :: isSorted
1448 : integer(TKR) :: rank(size(array, kind = IK))
1449 : end function
1450 : #endif
1451 :
1452 : #if SK3_ENABLED
1453 : module function getRankDenseCusCom_D1_PSSK3(array, isSorted) result(rank)
1454 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1455 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_PSSK3
1456 : #endif
1457 : use pm_kind, only: TKR => IK, SKC => SK3
1458 : use pm_container, only: css_pdt
1459 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1460 : procedure(logical(LK)) :: isSorted
1461 : integer(TKR) :: rank(size(array, kind = IK))
1462 : end function
1463 : #endif
1464 :
1465 : #if SK2_ENABLED
1466 : module function getRankDenseCusCom_D1_PSSK2(array, isSorted) result(rank)
1467 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1468 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_PSSK2
1469 : #endif
1470 : use pm_kind, only: TKR => IK, SKC => SK2
1471 : use pm_container, only: css_pdt
1472 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1473 : procedure(logical(LK)) :: isSorted
1474 : integer(TKR) :: rank(size(array, kind = IK))
1475 : end function
1476 : #endif
1477 :
1478 : #if SK1_ENABLED
1479 : module function getRankDenseCusCom_D1_PSSK1(array, isSorted) result(rank)
1480 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1481 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_PSSK1
1482 : #endif
1483 : use pm_kind, only: TKR => IK, SKC => SK1
1484 : use pm_container, only: css_pdt
1485 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
1486 : integer(TKR) :: rank(size(array, kind = IK))
1487 : procedure(logical(LK)) :: isSorted
1488 : end function
1489 : #endif
1490 :
1491 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1492 :
1493 : module function getRankDenseCusCom_D1_BSSK(array, isSorted) result(rank)
1494 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1495 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankDenseCusCom_D1_BSSK
1496 : #endif
1497 : use pm_kind, only: TKR => IK, SKC => SK
1498 : use pm_container, only: css_type
1499 : type(css_type) , intent(in) , contiguous :: array(:)
1500 : procedure(logical(LK)) :: isSorted
1501 : integer(TKR) :: rank(size(array, kind = IK))
1502 : end function
1503 :
1504 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1505 :
1506 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1507 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1508 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1509 :
1510 : end interface
1511 :
1512 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1513 :
1514 : !> \brief
1515 : !> Return the **Dense rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
1516 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
1517 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
1518 : !>
1519 : !> \details
1520 : !> This kind of ranking of values is widely known as <b>dense (`1223`) ranking</b>.<br>
1521 : !> In Dense ranking, items that compare equally receive the same ranking number, and the next items receive the immediately following ranking number.<br>
1522 : !> Equivalently, the ranking number of each item is `1` plus the number of items ranked above it that are distinct with respect to the ranking order.<br>
1523 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number 1 (*first*), *B* gets
1524 : !> ranking number `2` (*joint second*), *C* also gets ranking number `2` (*joint second*) and *D* gets ranking number `3` (*Third*).<br>
1525 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Dense ranking** `1223`.<br>
1526 : !> Dense ranking effective factorizes the array into classes of unique values. Therefore, the Dense rank of each element of the array
1527 : !> is simply its class **level**.
1528 : !>
1529 : !> \param[out] rank : The output `contiguous` array of rank `1` of type `integer` of default kind \IK
1530 : !> containing the ranks of the corresponding elements of `array`.<br>
1531 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
1532 : !> **Read `rank(i)` as the Dense rank of the `i`th element of `array`.**
1533 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
1534 : !> <ol>
1535 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
1536 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
1537 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
1538 : !> <li> type `integer` of kind \IKALL or,<br>
1539 : !> <li> type `logical` of kind \LKALL or,<br>
1540 : !> <li> type `complex` of kind \CKALL or,<br>
1541 : !> <li> type `real` of kind \RKALL,<br>
1542 : !> </ol>
1543 : !> or,
1544 : !> <ol>
1545 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
1546 : !> </ol>
1547 : !> whose elements rankings will be computed and returned.
1548 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type
1549 : !> and kind as the input `array`.<br>
1550 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
1551 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
1552 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
1553 : !> If `array` is a Fortran string (i.e., a scalar `character`),
1554 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
1555 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
1556 : !> \code{.F90}
1557 : !> function isSorted(a,b) result (sorted)
1558 : !> use pm_kind, only: SK, IK, LK, CK, RK
1559 : !> TYPE(KIND) , intent(in) :: a, b
1560 : !> logical(LK) :: sorted
1561 : !> end function
1562 : !> \endcode
1563 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
1564 : !> \code{.F90}
1565 : !> use pm_container, only: StrCon
1566 : !> use pm_kind, only: SK, IK, LK, CK, RK
1567 : !> character(*, SK), intent(in) :: a, b
1568 : !> integer(IK) , intent(in) :: a, b
1569 : !> logical(LK) , intent(in) :: a, b
1570 : !> complex(CK) , intent(in) :: a, b
1571 : !> real(RK) , intent(in) :: a, b
1572 : !> type(StrCon) , intent(in) :: a, b
1573 : !> \endcode
1574 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
1575 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
1576 : !> \code{.F90}
1577 : !> function isSorted(a,b) result (sorted)
1578 : !> character(1,SKC), intent(in) :: a, b
1579 : !> logical(LK) :: sorted
1580 : !> end function
1581 : !> \endcode
1582 : !> where `SKC` represents the kind of the input string argument `array`.<br>
1583 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
1584 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
1585 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
1586 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
1587 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
1588 : !>
1589 : !> \interface{setRankDense}
1590 : !> \code{.F90}
1591 : !>
1592 : !> use pm_arrayRank, only: setRankDense
1593 : !>
1594 : !> call setRankDense(rank, array)
1595 : !> call setRankDense(rank, array, isSorted)
1596 : !>
1597 : !> \endcode
1598 : !>
1599 : !> \warning
1600 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
1601 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
1602 : !> identify ties within the Dense ranking of the input `array`.
1603 : !>
1604 : !> \warnpure
1605 : !>
1606 : !> \warning
1607 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
1608 : !>
1609 : !> \see
1610 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
1611 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
1612 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
1613 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
1614 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
1615 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
1616 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
1617 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
1618 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
1619 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
1620 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
1621 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
1622 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
1623 : !>
1624 : !> \example{setRankDense}
1625 : !> \include{lineno} example/pm_arrayRank/setRankDense/main.F90
1626 : !> \compilef{setRankDense}
1627 : !> \output{setRankDense}
1628 : !> \include{lineno} example/pm_arrayRank/setRankDense/main.out.F90
1629 : !>
1630 : !> \test
1631 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
1632 : !>
1633 : !> \bug
1634 : !> \status \unresolved
1635 : !> \source \ifort{2021.5}
1636 : !> \desc
1637 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
1638 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
1639 : !> \remedy
1640 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
1641 : !>
1642 : !> \todo
1643 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
1644 : !>
1645 : !> \todo
1646 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
1647 : !>
1648 : !> \finmain{setRankDense}
1649 : !>
1650 : !> \author
1651 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1652 : interface setRankDense
1653 :
1654 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1655 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1656 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1657 :
1658 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1659 :
1660 : #if SK5_ENABLED
1661 : PURE module subroutine setRankDenseDefCom_D0_SK5(rank, array)
1662 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1663 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D0_SK5
1664 : #endif
1665 : use pm_kind, only: TKR => IK, SKC => SK5
1666 : character(*,SKC) , intent(in) :: array
1667 : integer(TKR) , intent(out) , contiguous :: rank(:)
1668 : end subroutine
1669 : #endif
1670 :
1671 : #if SK4_ENABLED
1672 : PURE module subroutine setRankDenseDefCom_D0_SK4(rank, array)
1673 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1674 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D0_SK4
1675 : #endif
1676 : use pm_kind, only: TKR => IK, SKC => SK4
1677 : character(*,SKC) , intent(in) :: array
1678 : integer(TKR) , intent(out) , contiguous :: rank(:)
1679 : end subroutine
1680 : #endif
1681 :
1682 : #if SK3_ENABLED
1683 : PURE module subroutine setRankDenseDefCom_D0_SK3(rank, array)
1684 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1685 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D0_SK3
1686 : #endif
1687 : use pm_kind, only: TKR => IK, SKC => SK3
1688 : character(*,SKC) , intent(in) :: array
1689 : integer(TKR) , intent(out) , contiguous :: rank(:)
1690 : end subroutine
1691 : #endif
1692 :
1693 : #if SK2_ENABLED
1694 : PURE module subroutine setRankDenseDefCom_D0_SK2(rank, array)
1695 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1696 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D0_SK2
1697 : #endif
1698 : use pm_kind, only: TKR => IK, SKC => SK2
1699 : character(*,SKC) , intent(in) :: array
1700 : integer(TKR) , intent(out) , contiguous :: rank(:)
1701 : end subroutine
1702 : #endif
1703 :
1704 : #if SK1_ENABLED
1705 : PURE module subroutine setRankDenseDefCom_D0_SK1(rank, array)
1706 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1707 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D0_SK1
1708 : #endif
1709 : use pm_kind, only: TKR => IK, SKC => SK1
1710 : character(*,SKC) , intent(in) :: array
1711 : integer(TKR) , intent(out) , contiguous :: rank(:)
1712 : end subroutine
1713 : #endif
1714 :
1715 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1716 :
1717 : #if SK5_ENABLED
1718 : PURE module subroutine setRankDenseDefCom_D1_SK5(rank, array)
1719 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1720 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_SK5
1721 : #endif
1722 : use pm_kind, only: TKR => IK, SKC => SK5
1723 : character(*,SKC) , intent(in) , contiguous :: array(:)
1724 : integer(TKR) , intent(out) , contiguous :: rank(:)
1725 : end subroutine
1726 : #endif
1727 :
1728 : #if SK4_ENABLED
1729 : PURE module subroutine setRankDenseDefCom_D1_SK4(rank, array)
1730 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1731 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_SK4
1732 : #endif
1733 : use pm_kind, only: TKR => IK, SKC => SK4
1734 : character(*,SKC) , intent(in) , contiguous :: array(:)
1735 : integer(TKR) , intent(out) , contiguous :: rank(:)
1736 : end subroutine
1737 : #endif
1738 :
1739 : #if SK3_ENABLED
1740 : PURE module subroutine setRankDenseDefCom_D1_SK3(rank, array)
1741 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1742 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_SK3
1743 : #endif
1744 : use pm_kind, only: TKR => IK, SKC => SK3
1745 : character(*,SKC) , intent(in) , contiguous :: array(:)
1746 : integer(TKR) , intent(out) , contiguous :: rank(:)
1747 : end subroutine
1748 : #endif
1749 :
1750 : #if SK2_ENABLED
1751 : PURE module subroutine setRankDenseDefCom_D1_SK2(rank, array)
1752 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1753 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_SK2
1754 : #endif
1755 : use pm_kind, only: TKR => IK, SKC => SK2
1756 : character(*,SKC) , intent(in) , contiguous :: array(:)
1757 : integer(TKR) , intent(out) , contiguous :: rank(:)
1758 : end subroutine
1759 : #endif
1760 :
1761 : #if SK1_ENABLED
1762 : PURE module subroutine setRankDenseDefCom_D1_SK1(rank, array)
1763 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1764 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_SK1
1765 : #endif
1766 : use pm_kind, only: TKR => IK, SKC => SK1
1767 : character(*,SKC) , intent(in) , contiguous :: array(:)
1768 : integer(TKR) , intent(out) , contiguous :: rank(:)
1769 : end subroutine
1770 : #endif
1771 :
1772 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1773 :
1774 : #if IK5_ENABLED
1775 : PURE module subroutine setRankDenseDefCom_D1_IK5(rank, array)
1776 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1777 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_IK5
1778 : #endif
1779 : use pm_kind, only: TKR => IK, IKC => IK5
1780 : integer(IKC) , intent(in) , contiguous :: array(:)
1781 : integer(TKR) , intent(out) , contiguous :: rank(:)
1782 : end subroutine
1783 : #endif
1784 :
1785 : #if IK4_ENABLED
1786 : PURE module subroutine setRankDenseDefCom_D1_IK4(rank, array)
1787 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1788 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_IK4
1789 : #endif
1790 : use pm_kind, only: TKR => IK, IKC => IK4
1791 : integer(IKC) , intent(in) , contiguous :: array(:)
1792 : integer(TKR) , intent(out) , contiguous :: rank(:)
1793 : end subroutine
1794 : #endif
1795 :
1796 : #if IK3_ENABLED
1797 : PURE module subroutine setRankDenseDefCom_D1_IK3(rank, array)
1798 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1799 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_IK3
1800 : #endif
1801 : use pm_kind, only: TKR => IK, IKC => IK3
1802 : integer(IKC) , intent(in) , contiguous :: array(:)
1803 : integer(TKR) , intent(out) , contiguous :: rank(:)
1804 : end subroutine
1805 : #endif
1806 :
1807 : #if IK2_ENABLED
1808 : PURE module subroutine setRankDenseDefCom_D1_IK2(rank, array)
1809 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1810 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_IK2
1811 : #endif
1812 : use pm_kind, only: TKR => IK, IKC => IK2
1813 : integer(IKC) , intent(in) , contiguous :: array(:)
1814 : integer(TKR) , intent(out) , contiguous :: rank(:)
1815 : end subroutine
1816 : #endif
1817 :
1818 : #if IK1_ENABLED
1819 : PURE module subroutine setRankDenseDefCom_D1_IK1(rank, array)
1820 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1821 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_IK1
1822 : #endif
1823 : use pm_kind, only: TKR => IK, IKC => IK1
1824 : integer(IKC) , intent(in) , contiguous :: array(:)
1825 : integer(TKR) , intent(out) , contiguous :: rank(:)
1826 : end subroutine
1827 : #endif
1828 :
1829 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1830 :
1831 : #if LK5_ENABLED
1832 : PURE module subroutine setRankDenseDefCom_D1_LK5(rank, array)
1833 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1834 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_LK5
1835 : #endif
1836 : use pm_kind, only: TKR => IK, LKC => LK5
1837 : logical(LKC) , intent(in) , contiguous :: array(:)
1838 : integer(TKR) , intent(out) , contiguous :: rank(:)
1839 : end subroutine
1840 : #endif
1841 :
1842 : #if LK4_ENABLED
1843 : PURE module subroutine setRankDenseDefCom_D1_LK4(rank, array)
1844 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1845 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_LK4
1846 : #endif
1847 : use pm_kind, only: TKR => IK, LKC => LK4
1848 : logical(LKC) , intent(in) , contiguous :: array(:)
1849 : integer(TKR) , intent(out) , contiguous :: rank(:)
1850 : end subroutine
1851 : #endif
1852 :
1853 : #if LK3_ENABLED
1854 : PURE module subroutine setRankDenseDefCom_D1_LK3(rank, array)
1855 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1856 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_LK3
1857 : #endif
1858 : use pm_kind, only: TKR => IK, LKC => LK3
1859 : logical(LKC) , intent(in) , contiguous :: array(:)
1860 : integer(TKR) , intent(out) , contiguous :: rank(:)
1861 : end subroutine
1862 : #endif
1863 :
1864 : #if LK2_ENABLED
1865 : PURE module subroutine setRankDenseDefCom_D1_LK2(rank, array)
1866 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1867 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_LK2
1868 : #endif
1869 : use pm_kind, only: TKR => IK, LKC => LK2
1870 : logical(LKC) , intent(in) , contiguous :: array(:)
1871 : integer(TKR) , intent(out) , contiguous :: rank(:)
1872 : end subroutine
1873 : #endif
1874 :
1875 : #if LK1_ENABLED
1876 : PURE module subroutine setRankDenseDefCom_D1_LK1(rank, array)
1877 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1878 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_LK1
1879 : #endif
1880 : use pm_kind, only: TKR => IK, LKC => LK1
1881 : logical(LKC) , intent(in) , contiguous :: array(:)
1882 : integer(TKR) , intent(out) , contiguous :: rank(:)
1883 : end subroutine
1884 : #endif
1885 :
1886 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1887 :
1888 : #if CK5_ENABLED
1889 : PURE module subroutine setRankDenseDefCom_D1_CK5(rank, array)
1890 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1891 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_CK5
1892 : #endif
1893 : use pm_kind, only: TKR => IK, CKC => CK5
1894 : complex(CKC) , intent(in) , contiguous :: array(:)
1895 : integer(TKR) , intent(out) , contiguous :: rank(:)
1896 : end subroutine
1897 : #endif
1898 :
1899 : #if CK4_ENABLED
1900 : PURE module subroutine setRankDenseDefCom_D1_CK4(rank, array)
1901 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1902 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_CK4
1903 : #endif
1904 : use pm_kind, only: TKR => IK, CKC => CK4
1905 : complex(CKC) , intent(in) , contiguous :: array(:)
1906 : integer(TKR) , intent(out) , contiguous :: rank(:)
1907 : end subroutine
1908 : #endif
1909 :
1910 : #if CK3_ENABLED
1911 : PURE module subroutine setRankDenseDefCom_D1_CK3(rank, array)
1912 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1913 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_CK3
1914 : #endif
1915 : use pm_kind, only: TKR => IK, CKC => CK3
1916 : complex(CKC) , intent(in) , contiguous :: array(:)
1917 : integer(TKR) , intent(out) , contiguous :: rank(:)
1918 : end subroutine
1919 : #endif
1920 :
1921 : #if CK2_ENABLED
1922 : PURE module subroutine setRankDenseDefCom_D1_CK2(rank, array)
1923 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1924 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_CK2
1925 : #endif
1926 : use pm_kind, only: TKR => IK, CKC => CK2
1927 : complex(CKC) , intent(in) , contiguous :: array(:)
1928 : integer(TKR) , intent(out) , contiguous :: rank(:)
1929 : end subroutine
1930 : #endif
1931 :
1932 : #if CK1_ENABLED
1933 : PURE module subroutine setRankDenseDefCom_D1_CK1(rank, array)
1934 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1935 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_CK1
1936 : #endif
1937 : use pm_kind, only: TKR => IK, CKC => CK1
1938 : complex(CKC) , intent(in) , contiguous :: array(:)
1939 : integer(TKR) , intent(out) , contiguous :: rank(:)
1940 : end subroutine
1941 : #endif
1942 :
1943 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1944 :
1945 : #if RK5_ENABLED
1946 : PURE module subroutine setRankDenseDefCom_D1_RK5(rank, array)
1947 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1948 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_RK5
1949 : #endif
1950 : use pm_kind, only: TKR => IK, RKC => RK5
1951 : real(RKC) , intent(in) , contiguous :: array(:)
1952 : integer(TKR) , intent(out) , contiguous :: rank(:)
1953 : end subroutine
1954 : #endif
1955 :
1956 : #if RK4_ENABLED
1957 : PURE module subroutine setRankDenseDefCom_D1_RK4(rank, array)
1958 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1959 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_RK4
1960 : #endif
1961 : use pm_kind, only: TKR => IK, RKC => RK4
1962 : real(RKC) , intent(in) , contiguous :: array(:)
1963 : integer(TKR) , intent(out) , contiguous :: rank(:)
1964 : end subroutine
1965 : #endif
1966 :
1967 : #if RK3_ENABLED
1968 : PURE module subroutine setRankDenseDefCom_D1_RK3(rank, array)
1969 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1970 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_RK3
1971 : #endif
1972 : use pm_kind, only: TKR => IK, RKC => RK3
1973 : real(RKC) , intent(in) , contiguous :: array(:)
1974 : integer(TKR) , intent(out) , contiguous :: rank(:)
1975 : end subroutine
1976 : #endif
1977 :
1978 : #if RK2_ENABLED
1979 : PURE module subroutine setRankDenseDefCom_D1_RK2(rank, array)
1980 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1981 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_RK2
1982 : #endif
1983 : use pm_kind, only: TKR => IK, RKC => RK2
1984 : real(RKC) , intent(in) , contiguous :: array(:)
1985 : integer(TKR) , intent(out) , contiguous :: rank(:)
1986 : end subroutine
1987 : #endif
1988 :
1989 : #if RK1_ENABLED
1990 : PURE module subroutine setRankDenseDefCom_D1_RK1(rank, array)
1991 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1992 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_RK1
1993 : #endif
1994 : use pm_kind, only: TKR => IK, RKC => RK1
1995 : real(RKC) , intent(in) , contiguous :: array(:)
1996 : integer(TKR) , intent(out) , contiguous :: rank(:)
1997 : end subroutine
1998 : #endif
1999 :
2000 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2001 :
2002 : #if SK5_ENABLED
2003 : PURE module subroutine setRankDenseDefCom_D1_PSSK5(rank, array)
2004 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2005 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_PSSK5
2006 : #endif
2007 : use pm_kind, only: TKR => IK, SKC => SK5
2008 : use pm_container, only: css_pdt
2009 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2010 : integer(TKR) , intent(out) , contiguous :: rank(:)
2011 : end subroutine
2012 : #endif
2013 :
2014 : #if SK4_ENABLED
2015 : PURE module subroutine setRankDenseDefCom_D1_PSSK4(rank, array)
2016 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2017 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_PSSK4
2018 : #endif
2019 : use pm_kind, only: TKR => IK, SKC => SK4
2020 : use pm_container, only: css_pdt
2021 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2022 : integer(TKR) , intent(out) , contiguous :: rank(:)
2023 : end subroutine
2024 : #endif
2025 :
2026 : #if SK3_ENABLED
2027 : PURE module subroutine setRankDenseDefCom_D1_PSSK3(rank, array)
2028 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2029 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_PSSK3
2030 : #endif
2031 : use pm_kind, only: TKR => IK, SKC => SK3
2032 : use pm_container, only: css_pdt
2033 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2034 : integer(TKR) , intent(out) , contiguous :: rank(:)
2035 : end subroutine
2036 : #endif
2037 :
2038 : #if SK2_ENABLED
2039 : PURE module subroutine setRankDenseDefCom_D1_PSSK2(rank, array)
2040 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2041 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_PSSK2
2042 : #endif
2043 : use pm_kind, only: TKR => IK, SKC => SK2
2044 : use pm_container, only: css_pdt
2045 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2046 : integer(TKR) , intent(out) , contiguous :: rank(:)
2047 : end subroutine
2048 : #endif
2049 :
2050 : #if SK1_ENABLED
2051 : PURE module subroutine setRankDenseDefCom_D1_PSSK1(rank, array)
2052 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2053 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_PSSK1
2054 : #endif
2055 : use pm_kind, only: TKR => IK, SKC => SK1
2056 : use pm_container, only: css_pdt
2057 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2058 : integer(TKR) , intent(out) , contiguous :: rank(:)
2059 : end subroutine
2060 : #endif
2061 :
2062 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2063 :
2064 : PURE module subroutine setRankDenseDefCom_D1_BSSK(rank, array)
2065 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2066 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseDefCom_D1_BSSK
2067 : #endif
2068 : use pm_kind, only: TKR => IK, SKC => SK
2069 : use pm_container, only: css_type
2070 : type(css_type) , intent(in) , contiguous :: array(:)
2071 : integer(TKR) , intent(out) , contiguous :: rank(:)
2072 : end subroutine
2073 :
2074 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2075 :
2076 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2077 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2078 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2079 :
2080 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2081 :
2082 : #if SK5_ENABLED
2083 : module subroutine setRankDenseCusCom_D0_SK5(rank, array, isSorted)
2084 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2085 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D0_SK5
2086 : #endif
2087 : use pm_kind, only: TKR => IK, SKC => SK5
2088 : character(*,SKC) , intent(in) :: array
2089 : integer(TKR) , intent(out) , contiguous :: rank(:)
2090 : procedure(logical(LK)) :: isSorted
2091 : end subroutine
2092 : #endif
2093 :
2094 : #if SK4_ENABLED
2095 : module subroutine setRankDenseCusCom_D0_SK4(rank, array, isSorted)
2096 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2097 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D0_SK4
2098 : #endif
2099 : use pm_kind, only: TKR => IK, SKC => SK4
2100 : character(*,SKC) , intent(in) :: array
2101 : integer(TKR) , intent(out) , contiguous :: rank(:)
2102 : procedure(logical(LK)) :: isSorted
2103 : end subroutine
2104 : #endif
2105 :
2106 : #if SK3_ENABLED
2107 : module subroutine setRankDenseCusCom_D0_SK3(rank, array, isSorted)
2108 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2109 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D0_SK3
2110 : #endif
2111 : use pm_kind, only: TKR => IK, SKC => SK3
2112 : character(*,SKC) , intent(in) :: array
2113 : integer(TKR) , intent(out) , contiguous :: rank(:)
2114 : procedure(logical(LK)) :: isSorted
2115 : end subroutine
2116 : #endif
2117 :
2118 : #if SK2_ENABLED
2119 : module subroutine setRankDenseCusCom_D0_SK2(rank, array, isSorted)
2120 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2121 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D0_SK2
2122 : #endif
2123 : use pm_kind, only: TKR => IK, SKC => SK2
2124 : character(*,SKC) , intent(in) :: array
2125 : integer(TKR) , intent(out) , contiguous :: rank(:)
2126 : procedure(logical(LK)) :: isSorted
2127 : end subroutine
2128 : #endif
2129 :
2130 : #if SK1_ENABLED
2131 : module subroutine setRankDenseCusCom_D0_SK1(rank, array, isSorted)
2132 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2133 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D0_SK1
2134 : #endif
2135 : use pm_kind, only: TKR => IK, SKC => SK1
2136 : character(*,SKC) , intent(in) :: array
2137 : integer(TKR) , intent(out) , contiguous :: rank(:)
2138 : procedure(logical(LK)) :: isSorted
2139 : end subroutine
2140 : #endif
2141 :
2142 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2143 :
2144 : #if SK5_ENABLED
2145 : module subroutine setRankDenseCusCom_D1_SK5(rank, array, isSorted)
2146 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2147 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_SK5
2148 : #endif
2149 : use pm_kind, only: TKR => IK, SKC => SK5
2150 : character(*,SKC) , intent(in) , contiguous :: array(:)
2151 : integer(TKR) , intent(out) , contiguous :: rank(:)
2152 : procedure(logical(LK)) :: isSorted
2153 : end subroutine
2154 : #endif
2155 :
2156 : #if SK4_ENABLED
2157 : module subroutine setRankDenseCusCom_D1_SK4(rank, array, isSorted)
2158 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2159 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_SK4
2160 : #endif
2161 : use pm_kind, only: TKR => IK, SKC => SK4
2162 : character(*,SKC) , intent(in) , contiguous :: array(:)
2163 : integer(TKR) , intent(out) , contiguous :: rank(:)
2164 : procedure(logical(LK)) :: isSorted
2165 : end subroutine
2166 : #endif
2167 :
2168 : #if SK3_ENABLED
2169 : module subroutine setRankDenseCusCom_D1_SK3(rank, array, isSorted)
2170 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2171 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_SK3
2172 : #endif
2173 : use pm_kind, only: TKR => IK, SKC => SK3
2174 : character(*,SKC) , intent(in) , contiguous :: array(:)
2175 : integer(TKR) , intent(out) , contiguous :: rank(:)
2176 : procedure(logical(LK)) :: isSorted
2177 : end subroutine
2178 : #endif
2179 :
2180 : #if SK2_ENABLED
2181 : module subroutine setRankDenseCusCom_D1_SK2(rank, array, isSorted)
2182 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2183 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_SK2
2184 : #endif
2185 : use pm_kind, only: TKR => IK, SKC => SK2
2186 : character(*,SKC) , intent(in) , contiguous :: array(:)
2187 : integer(TKR) , intent(out) , contiguous :: rank(:)
2188 : procedure(logical(LK)) :: isSorted
2189 : end subroutine
2190 : #endif
2191 :
2192 : #if SK1_ENABLED
2193 : module subroutine setRankDenseCusCom_D1_SK1(rank, array, isSorted)
2194 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2195 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_SK1
2196 : #endif
2197 : use pm_kind, only: TKR => IK, SKC => SK1
2198 : character(*,SKC) , intent(in) , contiguous :: array(:)
2199 : integer(TKR) , intent(out) , contiguous :: rank(:)
2200 : procedure(logical(LK)) :: isSorted
2201 : end subroutine
2202 : #endif
2203 :
2204 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2205 :
2206 : #if IK5_ENABLED
2207 : module subroutine setRankDenseCusCom_D1_IK5(rank, array, isSorted)
2208 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2209 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_IK5
2210 : #endif
2211 : use pm_kind, only: TKR => IK, IKC => IK5
2212 : integer(IKC) , intent(in) , contiguous :: array(:)
2213 : integer(TKR) , intent(out) , contiguous :: rank(:)
2214 : procedure(logical(LK)) :: isSorted
2215 : end subroutine
2216 : #endif
2217 :
2218 : #if IK4_ENABLED
2219 : module subroutine setRankDenseCusCom_D1_IK4(rank, array, isSorted)
2220 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2221 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_IK4
2222 : #endif
2223 : use pm_kind, only: TKR => IK, IKC => IK4
2224 : integer(IKC) , intent(in) , contiguous :: array(:)
2225 : integer(TKR) , intent(out) , contiguous :: rank(:)
2226 : procedure(logical(LK)) :: isSorted
2227 : end subroutine
2228 : #endif
2229 :
2230 : #if IK3_ENABLED
2231 : module subroutine setRankDenseCusCom_D1_IK3(rank, array, isSorted)
2232 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2233 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_IK3
2234 : #endif
2235 : use pm_kind, only: TKR => IK, IKC => IK3
2236 : integer(IKC) , intent(in) , contiguous :: array(:)
2237 : integer(TKR) , intent(out) , contiguous :: rank(:)
2238 : procedure(logical(LK)) :: isSorted
2239 : end subroutine
2240 : #endif
2241 :
2242 : #if IK2_ENABLED
2243 : module subroutine setRankDenseCusCom_D1_IK2(rank, array, isSorted)
2244 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2245 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_IK2
2246 : #endif
2247 : use pm_kind, only: TKR => IK, IKC => IK2
2248 : integer(IKC) , intent(in) , contiguous :: array(:)
2249 : integer(TKR) , intent(out) , contiguous :: rank(:)
2250 : procedure(logical(LK)) :: isSorted
2251 : end subroutine
2252 : #endif
2253 :
2254 : #if IK1_ENABLED
2255 : module subroutine setRankDenseCusCom_D1_IK1(rank, array, isSorted)
2256 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2257 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_IK1
2258 : #endif
2259 : use pm_kind, only: TKR => IK, IKC => IK1
2260 : integer(IKC) , intent(in) , contiguous :: array(:)
2261 : integer(TKR) , intent(out) , contiguous :: rank(:)
2262 : procedure(logical(LK)) :: isSorted
2263 : end subroutine
2264 : #endif
2265 :
2266 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2267 :
2268 : #if LK5_ENABLED
2269 : module subroutine setRankDenseCusCom_D1_LK5(rank, array, isSorted)
2270 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2271 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_LK5
2272 : #endif
2273 : use pm_kind, only: TKR => IK, LKC => LK5
2274 : logical(LKC) , intent(in) , contiguous :: array(:)
2275 : integer(TKR) , intent(out) , contiguous :: rank(:)
2276 : procedure(logical(LK)) :: isSorted
2277 : end subroutine
2278 : #endif
2279 :
2280 : #if LK4_ENABLED
2281 : module subroutine setRankDenseCusCom_D1_LK4(rank, array, isSorted)
2282 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2283 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_LK4
2284 : #endif
2285 : use pm_kind, only: TKR => IK, LKC => LK4
2286 : logical(LKC) , intent(in) , contiguous :: array(:)
2287 : integer(TKR) , intent(out) , contiguous :: rank(:)
2288 : procedure(logical(LK)) :: isSorted
2289 : end subroutine
2290 : #endif
2291 :
2292 : #if LK3_ENABLED
2293 : module subroutine setRankDenseCusCom_D1_LK3(rank, array, isSorted)
2294 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2295 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_LK3
2296 : #endif
2297 : use pm_kind, only: TKR => IK, LKC => LK3
2298 : logical(LKC) , intent(in) , contiguous :: array(:)
2299 : integer(TKR) , intent(out) , contiguous :: rank(:)
2300 : procedure(logical(LK)) :: isSorted
2301 : end subroutine
2302 : #endif
2303 :
2304 : #if LK2_ENABLED
2305 : module subroutine setRankDenseCusCom_D1_LK2(rank, array, isSorted)
2306 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2307 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_LK2
2308 : #endif
2309 : use pm_kind, only: TKR => IK, LKC => LK2
2310 : logical(LKC) , intent(in) , contiguous :: array(:)
2311 : integer(TKR) , intent(out) , contiguous :: rank(:)
2312 : procedure(logical(LK)) :: isSorted
2313 : end subroutine
2314 : #endif
2315 :
2316 : #if LK1_ENABLED
2317 : module subroutine setRankDenseCusCom_D1_LK1(rank, array, isSorted)
2318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2319 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_LK1
2320 : #endif
2321 : use pm_kind, only: TKR => IK, LKC => LK1
2322 : logical(LKC) , intent(in) , contiguous :: array(:)
2323 : integer(TKR) , intent(out) , contiguous :: rank(:)
2324 : procedure(logical(LK)) :: isSorted
2325 : end subroutine
2326 : #endif
2327 :
2328 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2329 :
2330 : #if CK5_ENABLED
2331 : module subroutine setRankDenseCusCom_D1_CK5(rank, array, isSorted)
2332 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2333 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_CK5
2334 : #endif
2335 : use pm_kind, only: TKR => IK, CKC => CK5
2336 : complex(CKC) , intent(in) , contiguous :: array(:)
2337 : integer(TKR) , intent(out) , contiguous :: rank(:)
2338 : procedure(logical(LK)) :: isSorted
2339 : end subroutine
2340 : #endif
2341 :
2342 : #if CK4_ENABLED
2343 : module subroutine setRankDenseCusCom_D1_CK4(rank, array, isSorted)
2344 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2345 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_CK4
2346 : #endif
2347 : use pm_kind, only: TKR => IK, CKC => CK4
2348 : complex(CKC) , intent(in) , contiguous :: array(:)
2349 : integer(TKR) , intent(out) , contiguous :: rank(:)
2350 : procedure(logical(LK)) :: isSorted
2351 : end subroutine
2352 : #endif
2353 :
2354 : #if CK3_ENABLED
2355 : module subroutine setRankDenseCusCom_D1_CK3(rank, array, isSorted)
2356 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2357 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_CK3
2358 : #endif
2359 : use pm_kind, only: TKR => IK, CKC => CK3
2360 : complex(CKC) , intent(in) , contiguous :: array(:)
2361 : integer(TKR) , intent(out) , contiguous :: rank(:)
2362 : procedure(logical(LK)) :: isSorted
2363 : end subroutine
2364 : #endif
2365 :
2366 : #if CK2_ENABLED
2367 : module subroutine setRankDenseCusCom_D1_CK2(rank, array, isSorted)
2368 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2369 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_CK2
2370 : #endif
2371 : use pm_kind, only: TKR => IK, CKC => CK2
2372 : complex(CKC) , intent(in) , contiguous :: array(:)
2373 : integer(TKR) , intent(out) , contiguous :: rank(:)
2374 : procedure(logical(LK)) :: isSorted
2375 : end subroutine
2376 : #endif
2377 :
2378 : #if CK1_ENABLED
2379 : module subroutine setRankDenseCusCom_D1_CK1(rank, array, isSorted)
2380 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2381 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_CK1
2382 : #endif
2383 : use pm_kind, only: TKR => IK, CKC => CK1
2384 : complex(CKC) , intent(in) , contiguous :: array(:)
2385 : integer(TKR) , intent(out) , contiguous :: rank(:)
2386 : procedure(logical(LK)) :: isSorted
2387 : end subroutine
2388 : #endif
2389 :
2390 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2391 :
2392 : #if RK5_ENABLED
2393 : module subroutine setRankDenseCusCom_D1_RK5(rank, array, isSorted)
2394 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2395 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_RK5
2396 : #endif
2397 : use pm_kind, only: TKR => IK, RKC => RK5
2398 : real(RKC) , intent(in) , contiguous :: array(:)
2399 : integer(TKR) , intent(out) , contiguous :: rank(:)
2400 : procedure(logical(LK)) :: isSorted
2401 : end subroutine
2402 : #endif
2403 :
2404 : #if RK4_ENABLED
2405 : module subroutine setRankDenseCusCom_D1_RK4(rank, array, isSorted)
2406 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2407 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_RK4
2408 : #endif
2409 : use pm_kind, only: TKR => IK, RKC => RK4
2410 : real(RKC) , intent(in) , contiguous :: array(:)
2411 : integer(TKR) , intent(out) , contiguous :: rank(:)
2412 : procedure(logical(LK)) :: isSorted
2413 : end subroutine
2414 : #endif
2415 :
2416 : #if RK3_ENABLED
2417 : module subroutine setRankDenseCusCom_D1_RK3(rank, array, isSorted)
2418 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2419 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_RK3
2420 : #endif
2421 : use pm_kind, only: TKR => IK, RKC => RK3
2422 : real(RKC) , intent(in) , contiguous :: array(:)
2423 : integer(TKR) , intent(out) , contiguous :: rank(:)
2424 : procedure(logical(LK)) :: isSorted
2425 : end subroutine
2426 : #endif
2427 :
2428 : #if RK2_ENABLED
2429 : module subroutine setRankDenseCusCom_D1_RK2(rank, array, isSorted)
2430 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2431 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_RK2
2432 : #endif
2433 : use pm_kind, only: TKR => IK, RKC => RK2
2434 : real(RKC) , intent(in) , contiguous :: array(:)
2435 : integer(TKR) , intent(out) , contiguous :: rank(:)
2436 : procedure(logical(LK)) :: isSorted
2437 : end subroutine
2438 : #endif
2439 :
2440 : #if RK1_ENABLED
2441 : module subroutine setRankDenseCusCom_D1_RK1(rank, array, isSorted)
2442 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2443 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_RK1
2444 : #endif
2445 : use pm_kind, only: TKR => IK, RKC => RK1
2446 : real(RKC) , intent(in) , contiguous :: array(:)
2447 : integer(TKR) , intent(out) , contiguous :: rank(:)
2448 : procedure(logical(LK)) :: isSorted
2449 : end subroutine
2450 : #endif
2451 :
2452 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2453 :
2454 : #if SK5_ENABLED
2455 : module subroutine setRankDenseCusCom_D1_PSSK5(rank, array, isSorted)
2456 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2457 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_PSSK5
2458 : #endif
2459 : use pm_kind, only: TKR => IK, SKC => SK5
2460 : use pm_container, only: css_pdt
2461 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2462 : integer(TKR) , intent(out) , contiguous :: rank(:)
2463 : procedure(logical(LK)) :: isSorted
2464 : end subroutine
2465 : #endif
2466 :
2467 : #if SK4_ENABLED
2468 : module subroutine setRankDenseCusCom_D1_PSSK4(rank, array, isSorted)
2469 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2470 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_PSSK4
2471 : #endif
2472 : use pm_kind, only: TKR => IK, SKC => SK4
2473 : use pm_container, only: css_pdt
2474 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2475 : integer(TKR) , intent(out) , contiguous :: rank(:)
2476 : procedure(logical(LK)) :: isSorted
2477 : end subroutine
2478 : #endif
2479 :
2480 : #if SK3_ENABLED
2481 : module subroutine setRankDenseCusCom_D1_PSSK3(rank, array, isSorted)
2482 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2483 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_PSSK3
2484 : #endif
2485 : use pm_kind, only: TKR => IK, SKC => SK3
2486 : use pm_container, only: css_pdt
2487 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2488 : integer(TKR) , intent(out) , contiguous :: rank(:)
2489 : procedure(logical(LK)) :: isSorted
2490 : end subroutine
2491 : #endif
2492 :
2493 : #if SK2_ENABLED
2494 : module subroutine setRankDenseCusCom_D1_PSSK2(rank, array, isSorted)
2495 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2496 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_PSSK2
2497 : #endif
2498 : use pm_kind, only: TKR => IK, SKC => SK2
2499 : use pm_container, only: css_pdt
2500 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2501 : integer(TKR) , intent(out) , contiguous :: rank(:)
2502 : procedure(logical(LK)) :: isSorted
2503 : end subroutine
2504 : #endif
2505 :
2506 : #if SK1_ENABLED
2507 : module subroutine setRankDenseCusCom_D1_PSSK1(rank, array, isSorted)
2508 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2509 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_PSSK1
2510 : #endif
2511 : use pm_kind, only: TKR => IK, SKC => SK1
2512 : use pm_container, only: css_pdt
2513 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
2514 : integer(TKR) , intent(out) , contiguous :: rank(:)
2515 : procedure(logical(LK)) :: isSorted
2516 : end subroutine
2517 : #endif
2518 :
2519 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2520 :
2521 : module subroutine setRankDenseCusCom_D1_BSSK(rank, array, isSorted)
2522 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2523 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankDenseCusCom_D1_BSSK
2524 : #endif
2525 : use pm_kind, only: TKR => IK, SKC => SK
2526 : use pm_container, only: css_type
2527 : type(css_type) , intent(in) , contiguous :: array(:)
2528 : integer(TKR) , intent(out) , contiguous :: rank(:)
2529 : procedure(logical(LK)) :: isSorted
2530 : end subroutine
2531 :
2532 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2533 :
2534 : end interface
2535 :
2536 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2537 :
2538 : !> \brief
2539 : !> Generate and return the **Fractional rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
2540 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
2541 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
2542 : !>
2543 : !> \details
2544 : !> This kind of ranking of values is widely known as <b>fractional (`1 2.5 2.5 4`) ranking</b>.<br>
2545 : !> In Fractional ranking, items that compare equal receive the same ranking number, which is the mean of what they would have under ordinal
2546 : !> rankings; equivalently, the ranking number of 1 plus the number of items ranked above it plus half the number of items equal to it.<br>
2547 : !> This strategy has the property that the sum of the ranking numbers is the same as under ordinal ranking.<br>
2548 : !> For this reason, it is used in computing Borda counts and ranking statistics (e.g., Spearman Correlation).<br>
2549 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number `1` (*first*),
2550 : !> *B* and *C* each get ranking number `2.5` (average of *joint second/third*) and *D* gets ranking number `4` (*fourth*).<br>
2551 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Fractional ranking** `1223`.<br>
2552 : !> **Example:**<br>
2553 : !> Suppose the data set is `1.0, 1.0, 2.0, 3.0, 3.0, 4.0, 5.0, 5.0, 5.0`.<br>
2554 : !> The ordinal ranks are `1, 2, 3, 4, 5, 6, 7, 8, 9`.<br>
2555 : !> For `v = 1.0`, the Fractional rank is the average of the ordinal ranks: `(1 + 2) / 2 = 1.5`.<br>
2556 : !> In a similar manner, for `v = 5.0`, the Fractional rank is `(7 + 8 + 9) / 3 = 8.0`.<br>
2557 : !> Thus the Fractional ranks are: `1.5, 1.5, 3.0, 4.5, 4.5, 6.0, 8.0, 8.0, 8.0`
2558 : !>
2559 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
2560 : !> <ol>
2561 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
2562 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
2563 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
2564 : !> <li> type `integer` of kind \IKALL or,<br>
2565 : !> <li> type `logical` of kind \LKALL or,<br>
2566 : !> <li> type `complex` of kind \CKALL or,<br>
2567 : !> <li> type `real` of kind \RKALL,<br>
2568 : !> </ol>
2569 : !> or,
2570 : !> <ol>
2571 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
2572 : !> </ol>
2573 : !> whose elements rankings will be computed and returned.
2574 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type and kind as the input `array`.<br>
2575 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
2576 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
2577 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
2578 : !> If `array` is a Fortran string (i.e., a scalar `character`),
2579 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
2580 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
2581 : !> \code{.F90}
2582 : !> function isSorted(a,b) result (sorted)
2583 : !> use pm_kind, only: SK, IK, LK, CK, RK
2584 : !> TYPE(KIND) , intent(in) :: a, b
2585 : !> logical(LK) :: sorted
2586 : !> end function
2587 : !> \endcode
2588 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
2589 : !> \code{.F90}
2590 : !> use pm_container, only: StrCon
2591 : !> use pm_kind, only: SK, IK, LK, CK, RK
2592 : !> character(*, SK), intent(in) :: a, b
2593 : !> integer(IK) , intent(in) :: a, b
2594 : !> logical(LK) , intent(in) :: a, b
2595 : !> complex(CK) , intent(in) :: a, b
2596 : !> real(RK) , intent(in) :: a, b
2597 : !> type(StrCon) , intent(in) :: a, b
2598 : !> \endcode
2599 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
2600 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
2601 : !> \code{.F90}
2602 : !> function isSorted(a,b) result (sorted)
2603 : !> character(1,SKC), intent(in) :: a, b
2604 : !> logical(LK) :: sorted
2605 : !> end function
2606 : !> \endcode
2607 : !> where `SKC` represents the kind of the input string argument `array`.<br>
2608 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
2609 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
2610 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
2611 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
2612 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
2613 : !>
2614 : !> \return
2615 : !> `rank(1:size(array)` : The output `contiguous` array of rank `1` of type `real` of default kind \RK containing the ranks of the corresponding elements of `array`.<br>
2616 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
2617 : !> **Read `rank(i)` as the Fractional rank of the `i`th element of `array`.**
2618 : !>
2619 : !> \interface{getRankFractional}
2620 : !> \code{.F90}
2621 : !>
2622 : !> use pm_arrayRank, only: getRankFractional
2623 : !>
2624 : !> rank(1:size(array)) = getRankFractional(array)
2625 : !> rank(1:size(array)) = getRankFractional(array, isSorted)
2626 : !>
2627 : !> \endcode
2628 : !>
2629 : !> \warning
2630 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
2631 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
2632 : !> identify ties within the Standard ranking of the input `array`.
2633 : !>
2634 : !> \warnpure
2635 : !>
2636 : !> \warning
2637 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
2638 : !>
2639 : !> \see
2640 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
2641 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
2642 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
2643 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
2644 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
2645 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
2646 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
2647 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
2648 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
2649 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
2650 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
2651 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
2652 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
2653 : !>
2654 : !> \example{getRankFractional}
2655 : !> \include{lineno} example/pm_arrayRank/getRankFractional/main.F90
2656 : !> \compilef{getRankFractional}
2657 : !> \output{getRankFractional}
2658 : !> \include{lineno} example/pm_arrayRank/getRankFractional/main.out.F90
2659 : !>
2660 : !> \test
2661 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
2662 : !>
2663 : !> \bug
2664 : !> \status \unresolved
2665 : !> \source \ifort{2021.5}
2666 : !> \desc
2667 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
2668 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
2669 : !> \remedy
2670 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
2671 : !>
2672 : !> \todo
2673 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
2674 : !>
2675 : !> \todo
2676 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
2677 : !>
2678 : !> \finmain{getRankFractional}
2679 : !>
2680 : !> \author
2681 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2682 : interface getRankFractional
2683 :
2684 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2685 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2686 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2687 :
2688 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2689 :
2690 : #if SK5_ENABLED
2691 : module function getRankFractionalDefCom_D0_SK5(array) result(rank)
2692 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2693 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D0_SK5
2694 : #endif
2695 : use pm_kind, only: TKR => RK, SKC => SK5
2696 : character(*,SKC) , intent(in) :: array
2697 : real(TKR) :: rank(len(array, IK))
2698 : end function
2699 : #endif
2700 :
2701 : #if SK4_ENABLED
2702 : module function getRankFractionalDefCom_D0_SK4(array) result(rank)
2703 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2704 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D0_SK4
2705 : #endif
2706 : use pm_kind, only: TKR => RK, SKC => SK4
2707 : character(*,SKC) , intent(in) :: array
2708 : real(TKR) :: rank(len(array, IK))
2709 : end function
2710 : #endif
2711 :
2712 : #if SK3_ENABLED
2713 : module function getRankFractionalDefCom_D0_SK3(array) result(rank)
2714 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2715 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D0_SK3
2716 : #endif
2717 : use pm_kind, only: TKR => RK, SKC => SK3
2718 : character(*,SKC) , intent(in) :: array
2719 : real(TKR) :: rank(len(array, IK))
2720 : end function
2721 : #endif
2722 :
2723 : #if SK2_ENABLED
2724 : module function getRankFractionalDefCom_D0_SK2(array) result(rank)
2725 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2726 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D0_SK2
2727 : #endif
2728 : use pm_kind, only: TKR => RK, SKC => SK2
2729 : character(*,SKC) , intent(in) :: array
2730 : real(TKR) :: rank(len(array, IK))
2731 : end function
2732 : #endif
2733 :
2734 : #if SK1_ENABLED
2735 : module function getRankFractionalDefCom_D0_SK1(array) result(rank)
2736 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2737 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D0_SK1
2738 : #endif
2739 : use pm_kind, only: TKR => RK, SKC => SK1
2740 : character(*,SKC) , intent(in) :: array
2741 : real(TKR) :: rank(len(array, IK))
2742 : end function
2743 : #endif
2744 :
2745 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2746 :
2747 : #if SK5_ENABLED
2748 : module function getRankFractionalDefCom_D1_SK5(array) result(rank)
2749 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2750 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_SK5
2751 : #endif
2752 : use pm_kind, only: TKR => RK, SKC => SK5
2753 : character(*,SKC) , intent(in) , contiguous :: array(:)
2754 : real(TKR) :: rank(size(array, kind = IK))
2755 : end function
2756 : #endif
2757 :
2758 : #if SK4_ENABLED
2759 : module function getRankFractionalDefCom_D1_SK4(array) result(rank)
2760 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2761 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_SK4
2762 : #endif
2763 : use pm_kind, only: TKR => RK, SKC => SK4
2764 : character(*,SKC) , intent(in) , contiguous :: array(:)
2765 : real(TKR) :: rank(size(array, kind = IK))
2766 : end function
2767 : #endif
2768 :
2769 : #if SK3_ENABLED
2770 : module function getRankFractionalDefCom_D1_SK3(array) result(rank)
2771 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2772 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_SK3
2773 : #endif
2774 : use pm_kind, only: TKR => RK, SKC => SK3
2775 : character(*,SKC) , intent(in) , contiguous :: array(:)
2776 : real(TKR) :: rank(size(array, kind = IK))
2777 : end function
2778 : #endif
2779 :
2780 : #if SK2_ENABLED
2781 : module function getRankFractionalDefCom_D1_SK2(array) result(rank)
2782 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2783 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_SK2
2784 : #endif
2785 : use pm_kind, only: TKR => RK, SKC => SK2
2786 : character(*,SKC) , intent(in) , contiguous :: array(:)
2787 : real(TKR) :: rank(size(array, kind = IK))
2788 : end function
2789 : #endif
2790 :
2791 : #if SK1_ENABLED
2792 : module function getRankFractionalDefCom_D1_SK1(array) result(rank)
2793 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2794 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_SK1
2795 : #endif
2796 : use pm_kind, only: TKR => RK, SKC => SK1
2797 : character(*,SKC) , intent(in) , contiguous :: array(:)
2798 : real(TKR) :: rank(size(array, kind = IK))
2799 : end function
2800 : #endif
2801 :
2802 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2803 :
2804 : #if IK5_ENABLED
2805 : module function getRankFractionalDefCom_D1_IK5(array) result(rank)
2806 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2807 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_IK5
2808 : #endif
2809 : use pm_kind, only: TKR => RK, IKC => IK5
2810 : integer(IKC) , intent(in) , contiguous :: array(:)
2811 : real(TKR) :: rank(size(array, kind = IK))
2812 : end function
2813 : #endif
2814 :
2815 : #if IK4_ENABLED
2816 : module function getRankFractionalDefCom_D1_IK4(array) result(rank)
2817 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2818 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_IK4
2819 : #endif
2820 : use pm_kind, only: TKR => RK, IKC => IK4
2821 : integer(IKC) , intent(in) , contiguous :: array(:)
2822 : real(TKR) :: rank(size(array, kind = IK))
2823 : end function
2824 : #endif
2825 :
2826 : #if IK3_ENABLED
2827 : module function getRankFractionalDefCom_D1_IK3(array) result(rank)
2828 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2829 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_IK3
2830 : #endif
2831 : use pm_kind, only: TKR => RK, IKC => IK3
2832 : integer(IKC) , intent(in) , contiguous :: array(:)
2833 : real(TKR) :: rank(size(array, kind = IK))
2834 : end function
2835 : #endif
2836 :
2837 : #if IK2_ENABLED
2838 : module function getRankFractionalDefCom_D1_IK2(array) result(rank)
2839 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2840 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_IK2
2841 : #endif
2842 : use pm_kind, only: TKR => RK, IKC => IK2
2843 : integer(IKC) , intent(in) , contiguous :: array(:)
2844 : real(TKR) :: rank(size(array, kind = IK))
2845 : end function
2846 : #endif
2847 :
2848 : #if IK1_ENABLED
2849 : module function getRankFractionalDefCom_D1_IK1(array) result(rank)
2850 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2851 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_IK1
2852 : #endif
2853 : use pm_kind, only: TKR => RK, IKC => IK1
2854 : integer(IKC) , intent(in) , contiguous :: array(:)
2855 : real(TKR) :: rank(size(array, kind = IK))
2856 : end function
2857 : #endif
2858 :
2859 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2860 :
2861 : #if LK5_ENABLED
2862 : module function getRankFractionalDefCom_D1_LK5(array) result(rank)
2863 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2864 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_LK5
2865 : #endif
2866 : use pm_kind, only: TKR => RK, LKC => LK5
2867 : logical(LKC) , intent(in) , contiguous :: array(:)
2868 : real(TKR) :: rank(size(array, kind = IK))
2869 : end function
2870 : #endif
2871 :
2872 : #if LK4_ENABLED
2873 : module function getRankFractionalDefCom_D1_LK4(array) result(rank)
2874 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2875 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_LK4
2876 : #endif
2877 : use pm_kind, only: TKR => RK, LKC => LK4
2878 : logical(LKC) , intent(in) , contiguous :: array(:)
2879 : real(TKR) :: rank(size(array, kind = IK))
2880 : end function
2881 : #endif
2882 :
2883 : #if LK3_ENABLED
2884 : module function getRankFractionalDefCom_D1_LK3(array) result(rank)
2885 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2886 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_LK3
2887 : #endif
2888 : use pm_kind, only: TKR => RK, LKC => LK3
2889 : logical(LKC) , intent(in) , contiguous :: array(:)
2890 : real(TKR) :: rank(size(array, kind = IK))
2891 : end function
2892 : #endif
2893 :
2894 : #if LK2_ENABLED
2895 : module function getRankFractionalDefCom_D1_LK2(array) result(rank)
2896 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2897 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_LK2
2898 : #endif
2899 : use pm_kind, only: TKR => RK, LKC => LK2
2900 : logical(LKC) , intent(in) , contiguous :: array(:)
2901 : real(TKR) :: rank(size(array, kind = IK))
2902 : end function
2903 : #endif
2904 :
2905 : #if LK1_ENABLED
2906 : module function getRankFractionalDefCom_D1_LK1(array) result(rank)
2907 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2908 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_LK1
2909 : #endif
2910 : use pm_kind, only: TKR => RK, LKC => LK1
2911 : logical(LKC) , intent(in) , contiguous :: array(:)
2912 : real(TKR) :: rank(size(array, kind = IK))
2913 : end function
2914 : #endif
2915 :
2916 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2917 :
2918 : #if CK5_ENABLED
2919 : module function getRankFractionalDefCom_D1_CK5(array) result(rank)
2920 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2921 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_CK5
2922 : #endif
2923 : use pm_kind, only: TKR => RK, CKC => CK5
2924 : complex(CKC) , intent(in) , contiguous :: array(:)
2925 : real(TKR) :: rank(size(array, kind = IK))
2926 : end function
2927 : #endif
2928 :
2929 : #if CK4_ENABLED
2930 : module function getRankFractionalDefCom_D1_CK4(array) result(rank)
2931 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2932 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_CK4
2933 : #endif
2934 : use pm_kind, only: TKR => RK, CKC => CK4
2935 : complex(CKC) , intent(in) , contiguous :: array(:)
2936 : real(TKR) :: rank(size(array, kind = IK))
2937 : end function
2938 : #endif
2939 :
2940 : #if CK3_ENABLED
2941 : module function getRankFractionalDefCom_D1_CK3(array) result(rank)
2942 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2943 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_CK3
2944 : #endif
2945 : use pm_kind, only: TKR => RK, CKC => CK3
2946 : complex(CKC) , intent(in) , contiguous :: array(:)
2947 : real(TKR) :: rank(size(array, kind = IK))
2948 : end function
2949 : #endif
2950 :
2951 : #if CK2_ENABLED
2952 : module function getRankFractionalDefCom_D1_CK2(array) result(rank)
2953 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2954 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_CK2
2955 : #endif
2956 : use pm_kind, only: TKR => RK, CKC => CK2
2957 : complex(CKC) , intent(in) , contiguous :: array(:)
2958 : real(TKR) :: rank(size(array, kind = IK))
2959 : end function
2960 : #endif
2961 :
2962 : #if CK1_ENABLED
2963 : module function getRankFractionalDefCom_D1_CK1(array) result(rank)
2964 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2965 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_CK1
2966 : #endif
2967 : use pm_kind, only: TKR => RK, CKC => CK1
2968 : complex(CKC) , intent(in) , contiguous :: array(:)
2969 : real(TKR) :: rank(size(array, kind = IK))
2970 : end function
2971 : #endif
2972 :
2973 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2974 :
2975 : #if RK5_ENABLED
2976 : module function getRankFractionalDefCom_D1_RK5(array) result(rank)
2977 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2978 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_RK5
2979 : #endif
2980 : use pm_kind, only: TKR => RK, RKC => RK5
2981 : real(RKC) , intent(in) , contiguous :: array(:)
2982 : real(TKR) :: rank(size(array, kind = IK))
2983 : end function
2984 : #endif
2985 :
2986 : #if RK4_ENABLED
2987 : module function getRankFractionalDefCom_D1_RK4(array) result(rank)
2988 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2989 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_RK4
2990 : #endif
2991 : use pm_kind, only: TKR => RK, RKC => RK4
2992 : real(RKC) , intent(in) , contiguous :: array(:)
2993 : real(TKR) :: rank(size(array, kind = IK))
2994 : end function
2995 : #endif
2996 :
2997 : #if RK3_ENABLED
2998 : module function getRankFractionalDefCom_D1_RK3(array) result(rank)
2999 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3000 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_RK3
3001 : #endif
3002 : use pm_kind, only: TKR => RK, RKC => RK3
3003 : real(RKC) , intent(in) , contiguous :: array(:)
3004 : real(TKR) :: rank(size(array, kind = IK))
3005 : end function
3006 : #endif
3007 :
3008 : #if RK2_ENABLED
3009 : module function getRankFractionalDefCom_D1_RK2(array) result(rank)
3010 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3011 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_RK2
3012 : #endif
3013 : use pm_kind, only: TKR => RK, RKC => RK2
3014 : real(RKC) , intent(in) , contiguous :: array(:)
3015 : real(TKR) :: rank(size(array, kind = IK))
3016 : end function
3017 : #endif
3018 :
3019 : #if RK1_ENABLED
3020 : module function getRankFractionalDefCom_D1_RK1(array) result(rank)
3021 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3022 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_RK1
3023 : #endif
3024 : use pm_kind, only: TKR => RK, RKC => RK1
3025 : real(RKC) , intent(in) , contiguous :: array(:)
3026 : real(TKR) :: rank(size(array, kind = IK))
3027 : end function
3028 : #endif
3029 :
3030 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3031 :
3032 : #if SK5_ENABLED
3033 : module function getRankFractionalDefCom_D1_PSSK5(array) result(rank)
3034 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3035 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_PSSK5
3036 : #endif
3037 : use pm_kind, only: TKR => RK, SKC => SK5
3038 : use pm_container, only: css_pdt
3039 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3040 : real(TKR) :: rank(size(array, kind = IK))
3041 : end function
3042 : #endif
3043 :
3044 : #if SK4_ENABLED
3045 : module function getRankFractionalDefCom_D1_PSSK4(array) result(rank)
3046 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3047 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_PSSK4
3048 : #endif
3049 : use pm_kind, only: TKR => RK, SKC => SK4
3050 : use pm_container, only: css_pdt
3051 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3052 : real(TKR) :: rank(size(array, kind = IK))
3053 : end function
3054 : #endif
3055 :
3056 : #if SK3_ENABLED
3057 : module function getRankFractionalDefCom_D1_PSSK3(array) result(rank)
3058 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3059 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_PSSK3
3060 : #endif
3061 : use pm_kind, only: TKR => RK, SKC => SK3
3062 : use pm_container, only: css_pdt
3063 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3064 : real(TKR) :: rank(size(array, kind = IK))
3065 : end function
3066 : #endif
3067 :
3068 : #if SK2_ENABLED
3069 : module function getRankFractionalDefCom_D1_PSSK2(array) result(rank)
3070 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3071 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_PSSK2
3072 : #endif
3073 : use pm_kind, only: TKR => RK, SKC => SK2
3074 : use pm_container, only: css_pdt
3075 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3076 : real(TKR) :: rank(size(array, kind = IK))
3077 : end function
3078 : #endif
3079 :
3080 : #if SK1_ENABLED
3081 : module function getRankFractionalDefCom_D1_PSSK1(array) result(rank)
3082 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3083 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_PSSK1
3084 : #endif
3085 : use pm_kind, only: TKR => RK, SKC => SK1
3086 : use pm_container, only: css_pdt
3087 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3088 : real(TKR) :: rank(size(array, kind = IK))
3089 : end function
3090 : #endif
3091 :
3092 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3093 :
3094 : module function getRankFractionalDefCom_D1_BSSK(array) result(rank)
3095 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3096 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalDefCom_D1_BSSK
3097 : #endif
3098 : use pm_kind, only: TKR => RK, SKC => SK
3099 : use pm_container, only: css_type
3100 : type(css_type) , intent(in) , contiguous :: array(:)
3101 : real(TKR) :: rank(size(array, kind = IK))
3102 : end function
3103 :
3104 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3105 :
3106 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3107 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3108 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3109 :
3110 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3111 :
3112 : #if SK5_ENABLED
3113 : module function getRankFractionalCusCom_D0_SK5(array, isSorted) result(rank)
3114 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3115 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D0_SK5
3116 : #endif
3117 : use pm_kind, only: TKR => RK, SKC => SK5
3118 : character(*,SKC) , intent(in) :: array
3119 : procedure(logical(LK)) :: isSorted
3120 : real(TKR) :: rank(len(array, IK))
3121 : end function
3122 : #endif
3123 :
3124 : #if SK4_ENABLED
3125 : module function getRankFractionalCusCom_D0_SK4(array, isSorted) result(rank)
3126 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3127 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D0_SK4
3128 : #endif
3129 : use pm_kind, only: TKR => RK, SKC => SK4
3130 : character(*,SKC) , intent(in) :: array
3131 : procedure(logical(LK)) :: isSorted
3132 : real(TKR) :: rank(len(array, IK))
3133 : end function
3134 : #endif
3135 :
3136 : #if SK3_ENABLED
3137 : module function getRankFractionalCusCom_D0_SK3(array, isSorted) result(rank)
3138 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3139 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D0_SK3
3140 : #endif
3141 : use pm_kind, only: TKR => RK, SKC => SK3
3142 : character(*,SKC) , intent(in) :: array
3143 : procedure(logical(LK)) :: isSorted
3144 : real(TKR) :: rank(len(array, IK))
3145 : end function
3146 : #endif
3147 :
3148 : #if SK2_ENABLED
3149 : module function getRankFractionalCusCom_D0_SK2(array, isSorted) result(rank)
3150 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3151 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D0_SK2
3152 : #endif
3153 : use pm_kind, only: TKR => RK, SKC => SK2
3154 : character(*,SKC) , intent(in) :: array
3155 : procedure(logical(LK)) :: isSorted
3156 : real(TKR) :: rank(len(array, IK))
3157 : end function
3158 : #endif
3159 :
3160 : #if SK1_ENABLED
3161 : module function getRankFractionalCusCom_D0_SK1(array, isSorted) result(rank)
3162 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3163 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D0_SK1
3164 : #endif
3165 : use pm_kind, only: TKR => RK, SKC => SK1
3166 : character(*,SKC) , intent(in) :: array
3167 : procedure(logical(LK)) :: isSorted
3168 : real(TKR) :: rank(len(array, IK))
3169 : end function
3170 : #endif
3171 :
3172 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3173 :
3174 : #if SK5_ENABLED
3175 : module function getRankFractionalCusCom_D1_SK5(array, isSorted) result(rank)
3176 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3177 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_SK5
3178 : #endif
3179 : use pm_kind, only: TKR => RK, SKC => SK5
3180 : character(*,SKC) , intent(in) , contiguous :: array(:)
3181 : procedure(logical(LK)) :: isSorted
3182 : real(TKR) :: rank(size(array, kind = IK))
3183 : end function
3184 : #endif
3185 :
3186 : #if SK4_ENABLED
3187 : module function getRankFractionalCusCom_D1_SK4(array, isSorted) result(rank)
3188 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3189 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_SK4
3190 : #endif
3191 : use pm_kind, only: TKR => RK, SKC => SK4
3192 : character(*,SKC) , intent(in) , contiguous :: array(:)
3193 : procedure(logical(LK)) :: isSorted
3194 : real(TKR) :: rank(size(array, kind = IK))
3195 : end function
3196 : #endif
3197 :
3198 : #if SK3_ENABLED
3199 : module function getRankFractionalCusCom_D1_SK3(array, isSorted) result(rank)
3200 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3201 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_SK3
3202 : #endif
3203 : use pm_kind, only: TKR => RK, SKC => SK3
3204 : character(*,SKC) , intent(in) , contiguous :: array(:)
3205 : procedure(logical(LK)) :: isSorted
3206 : real(TKR) :: rank(size(array, kind = IK))
3207 : end function
3208 : #endif
3209 :
3210 : #if SK2_ENABLED
3211 : module function getRankFractionalCusCom_D1_SK2(array, isSorted) result(rank)
3212 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3213 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_SK2
3214 : #endif
3215 : use pm_kind, only: TKR => RK, SKC => SK2
3216 : character(*,SKC) , intent(in) , contiguous :: array(:)
3217 : procedure(logical(LK)) :: isSorted
3218 : real(TKR) :: rank(size(array, kind = IK))
3219 : end function
3220 : #endif
3221 :
3222 : #if SK1_ENABLED
3223 : module function getRankFractionalCusCom_D1_SK1(array, isSorted) result(rank)
3224 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3225 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_SK1
3226 : #endif
3227 : use pm_kind, only: TKR => RK, SKC => SK1
3228 : character(*,SKC) , intent(in) , contiguous :: array(:)
3229 : procedure(logical(LK)) :: isSorted
3230 : real(TKR) :: rank(size(array, kind = IK))
3231 : end function
3232 : #endif
3233 :
3234 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3235 :
3236 : #if IK5_ENABLED
3237 : module function getRankFractionalCusCom_D1_IK5(array, isSorted) result(rank)
3238 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3239 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_IK5
3240 : #endif
3241 : use pm_kind, only: TKR => RK, IKC => IK5
3242 : integer(IKC) , intent(in) , contiguous :: array(:)
3243 : procedure(logical(LK)) :: isSorted
3244 : real(TKR) :: rank(size(array, kind = IK))
3245 : end function
3246 : #endif
3247 :
3248 : #if IK4_ENABLED
3249 : module function getRankFractionalCusCom_D1_IK4(array, isSorted) result(rank)
3250 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3251 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_IK4
3252 : #endif
3253 : use pm_kind, only: TKR => RK, IKC => IK4
3254 : integer(IKC) , intent(in) , contiguous :: array(:)
3255 : procedure(logical(LK)) :: isSorted
3256 : real(TKR) :: rank(size(array, kind = IK))
3257 : end function
3258 : #endif
3259 :
3260 : #if IK3_ENABLED
3261 : module function getRankFractionalCusCom_D1_IK3(array, isSorted) result(rank)
3262 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3263 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_IK3
3264 : #endif
3265 : use pm_kind, only: TKR => RK, IKC => IK3
3266 : integer(IKC) , intent(in) , contiguous :: array(:)
3267 : procedure(logical(LK)) :: isSorted
3268 : real(TKR) :: rank(size(array, kind = IK))
3269 : end function
3270 : #endif
3271 :
3272 : #if IK2_ENABLED
3273 : module function getRankFractionalCusCom_D1_IK2(array, isSorted) result(rank)
3274 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3275 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_IK2
3276 : #endif
3277 : use pm_kind, only: TKR => RK, IKC => IK2
3278 : integer(IKC) , intent(in) , contiguous :: array(:)
3279 : procedure(logical(LK)) :: isSorted
3280 : real(TKR) :: rank(size(array, kind = IK))
3281 : end function
3282 : #endif
3283 :
3284 : #if IK1_ENABLED
3285 : module function getRankFractionalCusCom_D1_IK1(array, isSorted) result(rank)
3286 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3287 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_IK1
3288 : #endif
3289 : use pm_kind, only: TKR => RK, IKC => IK1
3290 : integer(IKC) , intent(in) , contiguous :: array(:)
3291 : procedure(logical(LK)) :: isSorted
3292 : real(TKR) :: rank(size(array, kind = IK))
3293 : end function
3294 : #endif
3295 :
3296 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3297 :
3298 : #if LK5_ENABLED
3299 : module function getRankFractionalCusCom_D1_LK5(array, isSorted) result(rank)
3300 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3301 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_LK5
3302 : #endif
3303 : use pm_kind, only: TKR => RK, LKC => LK5
3304 : logical(LKC) , intent(in) , contiguous :: array(:)
3305 : procedure(logical(LK)) :: isSorted
3306 : real(TKR) :: rank(size(array, kind = IK))
3307 : end function
3308 : #endif
3309 :
3310 : #if LK4_ENABLED
3311 : module function getRankFractionalCusCom_D1_LK4(array, isSorted) result(rank)
3312 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3313 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_LK4
3314 : #endif
3315 : use pm_kind, only: TKR => RK, LKC => LK4
3316 : logical(LKC) , intent(in) , contiguous :: array(:)
3317 : procedure(logical(LK)) :: isSorted
3318 : real(TKR) :: rank(size(array, kind = IK))
3319 : end function
3320 : #endif
3321 :
3322 : #if LK3_ENABLED
3323 : module function getRankFractionalCusCom_D1_LK3(array, isSorted) result(rank)
3324 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3325 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_LK3
3326 : #endif
3327 : use pm_kind, only: TKR => RK, LKC => LK3
3328 : logical(LKC) , intent(in) , contiguous :: array(:)
3329 : procedure(logical(LK)) :: isSorted
3330 : real(TKR) :: rank(size(array, kind = IK))
3331 : end function
3332 : #endif
3333 :
3334 : #if LK2_ENABLED
3335 : module function getRankFractionalCusCom_D1_LK2(array, isSorted) result(rank)
3336 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3337 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_LK2
3338 : #endif
3339 : use pm_kind, only: TKR => RK, LKC => LK2
3340 : logical(LKC) , intent(in) , contiguous :: array(:)
3341 : procedure(logical(LK)) :: isSorted
3342 : real(TKR) :: rank(size(array, kind = IK))
3343 : end function
3344 : #endif
3345 :
3346 : #if LK1_ENABLED
3347 : module function getRankFractionalCusCom_D1_LK1(array, isSorted) result(rank)
3348 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3349 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_LK1
3350 : #endif
3351 : use pm_kind, only: TKR => RK, LKC => LK1
3352 : logical(LKC) , intent(in) , contiguous :: array(:)
3353 : procedure(logical(LK)) :: isSorted
3354 : real(TKR) :: rank(size(array, kind = IK))
3355 : end function
3356 : #endif
3357 :
3358 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3359 :
3360 : #if CK5_ENABLED
3361 : module function getRankFractionalCusCom_D1_CK5(array, isSorted) result(rank)
3362 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3363 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_CK5
3364 : #endif
3365 : use pm_kind, only: TKR => RK, CKC => CK5
3366 : complex(CKC) , intent(in) , contiguous :: array(:)
3367 : procedure(logical(LK)) :: isSorted
3368 : real(TKR) :: rank(size(array, kind = IK))
3369 : end function
3370 : #endif
3371 :
3372 : #if CK4_ENABLED
3373 : module function getRankFractionalCusCom_D1_CK4(array, isSorted) result(rank)
3374 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3375 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_CK4
3376 : #endif
3377 : use pm_kind, only: TKR => RK, CKC => CK4
3378 : complex(CKC) , intent(in) , contiguous :: array(:)
3379 : procedure(logical(LK)) :: isSorted
3380 : real(TKR) :: rank(size(array, kind = IK))
3381 : end function
3382 : #endif
3383 :
3384 : #if CK3_ENABLED
3385 : module function getRankFractionalCusCom_D1_CK3(array, isSorted) result(rank)
3386 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3387 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_CK3
3388 : #endif
3389 : use pm_kind, only: TKR => RK, CKC => CK3
3390 : complex(CKC) , intent(in) , contiguous :: array(:)
3391 : procedure(logical(LK)) :: isSorted
3392 : real(TKR) :: rank(size(array, kind = IK))
3393 : end function
3394 : #endif
3395 :
3396 : #if CK2_ENABLED
3397 : module function getRankFractionalCusCom_D1_CK2(array, isSorted) result(rank)
3398 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3399 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_CK2
3400 : #endif
3401 : use pm_kind, only: TKR => RK, CKC => CK2
3402 : complex(CKC) , intent(in) , contiguous :: array(:)
3403 : procedure(logical(LK)) :: isSorted
3404 : real(TKR) :: rank(size(array, kind = IK))
3405 : end function
3406 : #endif
3407 :
3408 : #if CK1_ENABLED
3409 : module function getRankFractionalCusCom_D1_CK1(array, isSorted) result(rank)
3410 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3411 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_CK1
3412 : #endif
3413 : use pm_kind, only: TKR => RK, CKC => CK1
3414 : complex(CKC) , intent(in) , contiguous :: array(:)
3415 : procedure(logical(LK)) :: isSorted
3416 : real(TKR) :: rank(size(array, kind = IK))
3417 : end function
3418 : #endif
3419 :
3420 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3421 :
3422 : #if RK5_ENABLED
3423 : module function getRankFractionalCusCom_D1_RK5(array, isSorted) result(rank)
3424 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3425 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_RK5
3426 : #endif
3427 : use pm_kind, only: TKR => RK, RKC => RK5
3428 : real(RKC) , intent(in) , contiguous :: array(:)
3429 : procedure(logical(LK)) :: isSorted
3430 : real(TKR) :: rank(size(array, kind = IK))
3431 : end function
3432 : #endif
3433 :
3434 : #if RK4_ENABLED
3435 : module function getRankFractionalCusCom_D1_RK4(array, isSorted) result(rank)
3436 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3437 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_RK4
3438 : #endif
3439 : use pm_kind, only: TKR => RK, RKC => RK4
3440 : real(RKC) , intent(in) , contiguous :: array(:)
3441 : procedure(logical(LK)) :: isSorted
3442 : real(TKR) :: rank(size(array, kind = IK))
3443 : end function
3444 : #endif
3445 :
3446 : #if RK3_ENABLED
3447 : module function getRankFractionalCusCom_D1_RK3(array, isSorted) result(rank)
3448 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3449 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_RK3
3450 : #endif
3451 : use pm_kind, only: TKR => RK, RKC => RK3
3452 : real(RKC) , intent(in) , contiguous :: array(:)
3453 : procedure(logical(LK)) :: isSorted
3454 : real(TKR) :: rank(size(array, kind = IK))
3455 : end function
3456 : #endif
3457 :
3458 : #if RK2_ENABLED
3459 : module function getRankFractionalCusCom_D1_RK2(array, isSorted) result(rank)
3460 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3461 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_RK2
3462 : #endif
3463 : use pm_kind, only: TKR => RK, RKC => RK2
3464 : real(RKC) , intent(in) , contiguous :: array(:)
3465 : procedure(logical(LK)) :: isSorted
3466 : real(TKR) :: rank(size(array, kind = IK))
3467 : end function
3468 : #endif
3469 :
3470 : #if RK1_ENABLED
3471 : module function getRankFractionalCusCom_D1_RK1(array, isSorted) result(rank)
3472 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3473 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_RK1
3474 : #endif
3475 : use pm_kind, only: TKR => RK, RKC => RK1
3476 : real(RKC) , intent(in) , contiguous :: array(:)
3477 : procedure(logical(LK)) :: isSorted
3478 : real(TKR) :: rank(size(array, kind = IK))
3479 : end function
3480 : #endif
3481 :
3482 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3483 :
3484 : #if SK5_ENABLED
3485 : module function getRankFractionalCusCom_D1_PSSK5(array, isSorted) result(rank)
3486 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3487 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_PSSK5
3488 : #endif
3489 : use pm_kind, only: TKR => RK, SKC => SK5
3490 : use pm_container, only: css_pdt
3491 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3492 : procedure(logical(LK)) :: isSorted
3493 : real(TKR) :: rank(size(array, kind = IK))
3494 : end function
3495 : #endif
3496 :
3497 : #if SK4_ENABLED
3498 : module function getRankFractionalCusCom_D1_PSSK4(array, isSorted) result(rank)
3499 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3500 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_PSSK4
3501 : #endif
3502 : use pm_kind, only: TKR => RK, SKC => SK4
3503 : use pm_container, only: css_pdt
3504 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3505 : procedure(logical(LK)) :: isSorted
3506 : real(TKR) :: rank(size(array, kind = IK))
3507 : end function
3508 : #endif
3509 :
3510 : #if SK3_ENABLED
3511 : module function getRankFractionalCusCom_D1_PSSK3(array, isSorted) result(rank)
3512 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3513 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_PSSK3
3514 : #endif
3515 : use pm_kind, only: TKR => RK, SKC => SK3
3516 : use pm_container, only: css_pdt
3517 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3518 : procedure(logical(LK)) :: isSorted
3519 : real(TKR) :: rank(size(array, kind = IK))
3520 : end function
3521 : #endif
3522 :
3523 : #if SK2_ENABLED
3524 : module function getRankFractionalCusCom_D1_PSSK2(array, isSorted) result(rank)
3525 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3526 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_PSSK2
3527 : #endif
3528 : use pm_kind, only: TKR => RK, SKC => SK2
3529 : use pm_container, only: css_pdt
3530 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3531 : procedure(logical(LK)) :: isSorted
3532 : real(TKR) :: rank(size(array, kind = IK))
3533 : end function
3534 : #endif
3535 :
3536 : #if SK1_ENABLED
3537 : module function getRankFractionalCusCom_D1_PSSK1(array, isSorted) result(rank)
3538 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3539 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_PSSK1
3540 : #endif
3541 : use pm_kind, only: TKR => RK, SKC => SK1
3542 : use pm_container, only: css_pdt
3543 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
3544 : real(TKR) :: rank(size(array, kind = IK))
3545 : procedure(logical(LK)) :: isSorted
3546 : end function
3547 : #endif
3548 :
3549 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3550 :
3551 : module function getRankFractionalCusCom_D1_BSSK(array, isSorted) result(rank)
3552 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3553 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankFractionalCusCom_D1_BSSK
3554 : #endif
3555 : use pm_kind, only: TKR => RK, SKC => SK
3556 : use pm_container, only: css_type
3557 : type(css_type) , intent(in) , contiguous :: array(:)
3558 : procedure(logical(LK)) :: isSorted
3559 : real(TKR) :: rank(size(array, kind = IK))
3560 : end function
3561 :
3562 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3563 :
3564 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3565 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3566 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3567 :
3568 : end interface
3569 :
3570 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3571 :
3572 : !> \brief
3573 : !> Return the **Fractional rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
3574 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
3575 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
3576 : !>
3577 : !> \details
3578 : !> This kind of ranking of values is widely known as <b>fractional (`1 2.5 2.5 4`) ranking</b>.<br>
3579 : !> In Fractional ranking, items that compare equal receive the same ranking number, which is the mean of what they would have under ordinal
3580 : !> rankings; equivalently, the ranking number of 1 plus the number of items ranked above it plus half the number of items equal to it.<br>
3581 : !> This strategy has the property that the sum of the ranking numbers is the same as under ordinal ranking.<br>
3582 : !> For this reason, it is used in computing Borda counts and ranking statistics (e.g., Spearman Correlation).<br>
3583 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number `1` (*first*),
3584 : !> *B* and *C* each get ranking number `2.5` (average of *joint second/third*) and *D* gets ranking number `4` (*fourth*).<br>
3585 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Fractional ranking** `1223`.<br>
3586 : !> **Example:**<br>
3587 : !> Suppose the data set is `1.0, 1.0, 2.0, 3.0, 3.0, 4.0, 5.0, 5.0, 5.0`.<br>
3588 : !> The ordinal ranks are `1, 2, 3, 4, 5, 6, 7, 8, 9`.<br>
3589 : !> For `v = 1.0`, the Fractional rank is the average of the ordinal ranks: `(1 + 2) / 2 = 1.5`.<br>
3590 : !> In a similar manner, for `v = 5.0`, the Fractional rank is `(7 + 8 + 9) / 3 = 8.0`.<br>
3591 : !> Thus the Fractional ranks are: `1.5, 1.5, 3.0, 4.5, 4.5, 6.0, 8.0, 8.0, 8.0`
3592 : !>
3593 : !> \param[out] rank : The output `contiguous` array of rank `1` of type `real` of default kind \RK
3594 : !> containing the ranks of the corresponding elements of `array`.<br>
3595 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
3596 : !> **Read `rank(i)` as the Fractional rank of the `i`th element of `array`.**
3597 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
3598 : !> <ol>
3599 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
3600 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
3601 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
3602 : !> <li> type `integer` of kind \IKALL or,<br>
3603 : !> <li> type `logical` of kind \LKALL or,<br>
3604 : !> <li> type `complex` of kind \CKALL or,<br>
3605 : !> <li> type `real` of kind \RKALL,<br>
3606 : !> </ol>
3607 : !> or,
3608 : !> <ol>
3609 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
3610 : !> </ol>
3611 : !> whose elements rankings will be computed and returned.
3612 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type
3613 : !> and kind as the input `array`.<br>
3614 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
3615 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
3616 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
3617 : !> If `array` is a Fortran string (i.e., a scalar `character`),
3618 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
3619 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
3620 : !> \code{.F90}
3621 : !> function isSorted(a,b) result (sorted)
3622 : !> use pm_kind, only: SK, IK, LK, CK, RK
3623 : !> TYPE(KIND) , intent(in) :: a, b
3624 : !> logical(LK) :: sorted
3625 : !> end function
3626 : !> \endcode
3627 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
3628 : !> \code{.F90}
3629 : !> use pm_container, only: StrCon
3630 : !> use pm_kind, only: SK, IK, LK, CK, RK
3631 : !> character(*, SK), intent(in) :: a, b
3632 : !> integer(IK) , intent(in) :: a, b
3633 : !> logical(LK) , intent(in) :: a, b
3634 : !> complex(CK) , intent(in) :: a, b
3635 : !> real(RK) , intent(in) :: a, b
3636 : !> type(StrCon) , intent(in) :: a, b
3637 : !> \endcode
3638 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
3639 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
3640 : !> \code{.F90}
3641 : !> function isSorted(a,b) result (sorted)
3642 : !> character(1,SKC), intent(in) :: a, b
3643 : !> logical(LK) :: sorted
3644 : !> end function
3645 : !> \endcode
3646 : !> where `SKC` represents the kind of the input string argument `array`.<br>
3647 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
3648 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
3649 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired. In such cases,
3650 : !> user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
3651 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
3652 : !>
3653 : !> \interface{setRankFractional}
3654 : !> \code{.F90}
3655 : !>
3656 : !> use pm_arrayRank, only: setRankFractional
3657 : !>
3658 : !> call setRankFractional(rank, array)
3659 : !> call setRankFractional(rank, array, isSorted)
3660 : !>
3661 : !> \endcode
3662 : !>
3663 : !> \warning
3664 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
3665 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
3666 : !> identify ties within the Fractional ranking of the input `array`.
3667 : !>
3668 : !> \warnpure
3669 : !>
3670 : !> \warning
3671 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
3672 : !>
3673 : !> \see
3674 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
3675 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
3676 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
3677 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
3678 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
3679 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
3680 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
3681 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
3682 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
3683 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
3684 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
3685 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
3686 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
3687 : !>
3688 : !> \example{setRankFractional}
3689 : !> \include{lineno} example/pm_arrayRank/setRankFractional/main.F90
3690 : !> \compilef{setRankFractional}
3691 : !> \output{setRankFractional}
3692 : !> \include{lineno} example/pm_arrayRank/setRankFractional/main.out.F90
3693 : !>
3694 : !> \test
3695 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
3696 : !>
3697 : !> \bug
3698 : !> \status \unresolved
3699 : !> \source \ifort{2021.5}
3700 : !> \desc
3701 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
3702 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
3703 : !> \remedy
3704 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
3705 : !>
3706 : !> \todo
3707 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
3708 : !>
3709 : !> \todo
3710 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
3711 : !>
3712 : !> \finmain{setRankFractional}
3713 : !>
3714 : !> \author
3715 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3716 : interface setRankFractional
3717 :
3718 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3719 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3720 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3721 :
3722 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3723 :
3724 : #if SK5_ENABLED
3725 : PURE module subroutine setRankFractionalDefCom_D0_SK5(rank, array)
3726 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3727 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D0_SK5
3728 : #endif
3729 : use pm_kind, only: TKR => RK, SKC => SK5
3730 : character(*,SKC) , intent(in) :: array
3731 : real(TKR) , intent(out) , contiguous :: rank(:)
3732 : end subroutine
3733 : #endif
3734 :
3735 : #if SK4_ENABLED
3736 : PURE module subroutine setRankFractionalDefCom_D0_SK4(rank, array)
3737 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3738 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D0_SK4
3739 : #endif
3740 : use pm_kind, only: TKR => RK, SKC => SK4
3741 : character(*,SKC) , intent(in) :: array
3742 : real(TKR) , intent(out) , contiguous :: rank(:)
3743 : end subroutine
3744 : #endif
3745 :
3746 : #if SK3_ENABLED
3747 : PURE module subroutine setRankFractionalDefCom_D0_SK3(rank, array)
3748 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3749 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D0_SK3
3750 : #endif
3751 : use pm_kind, only: TKR => RK, SKC => SK3
3752 : character(*,SKC) , intent(in) :: array
3753 : real(TKR) , intent(out) , contiguous :: rank(:)
3754 : end subroutine
3755 : #endif
3756 :
3757 : #if SK2_ENABLED
3758 : PURE module subroutine setRankFractionalDefCom_D0_SK2(rank, array)
3759 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3760 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D0_SK2
3761 : #endif
3762 : use pm_kind, only: TKR => RK, SKC => SK2
3763 : character(*,SKC) , intent(in) :: array
3764 : real(TKR) , intent(out) , contiguous :: rank(:)
3765 : end subroutine
3766 : #endif
3767 :
3768 : #if SK1_ENABLED
3769 : PURE module subroutine setRankFractionalDefCom_D0_SK1(rank, array)
3770 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3771 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D0_SK1
3772 : #endif
3773 : use pm_kind, only: TKR => RK, SKC => SK1
3774 : character(*,SKC) , intent(in) :: array
3775 : real(TKR) , intent(out) , contiguous :: rank(:)
3776 : end subroutine
3777 : #endif
3778 :
3779 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3780 :
3781 : #if SK5_ENABLED
3782 : PURE module subroutine setRankFractionalDefCom_D1_SK5(rank, array)
3783 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3784 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_SK5
3785 : #endif
3786 : use pm_kind, only: TKR => RK, SKC => SK5
3787 : character(*,SKC) , intent(in) , contiguous :: array(:)
3788 : real(TKR) , intent(out) , contiguous :: rank(:)
3789 : end subroutine
3790 : #endif
3791 :
3792 : #if SK4_ENABLED
3793 : PURE module subroutine setRankFractionalDefCom_D1_SK4(rank, array)
3794 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3795 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_SK4
3796 : #endif
3797 : use pm_kind, only: TKR => RK, SKC => SK4
3798 : character(*,SKC) , intent(in) , contiguous :: array(:)
3799 : real(TKR) , intent(out) , contiguous :: rank(:)
3800 : end subroutine
3801 : #endif
3802 :
3803 : #if SK3_ENABLED
3804 : PURE module subroutine setRankFractionalDefCom_D1_SK3(rank, array)
3805 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3806 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_SK3
3807 : #endif
3808 : use pm_kind, only: TKR => RK, SKC => SK3
3809 : character(*,SKC) , intent(in) , contiguous :: array(:)
3810 : real(TKR) , intent(out) , contiguous :: rank(:)
3811 : end subroutine
3812 : #endif
3813 :
3814 : #if SK2_ENABLED
3815 : PURE module subroutine setRankFractionalDefCom_D1_SK2(rank, array)
3816 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3817 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_SK2
3818 : #endif
3819 : use pm_kind, only: TKR => RK, SKC => SK2
3820 : character(*,SKC) , intent(in) , contiguous :: array(:)
3821 : real(TKR) , intent(out) , contiguous :: rank(:)
3822 : end subroutine
3823 : #endif
3824 :
3825 : #if SK1_ENABLED
3826 : PURE module subroutine setRankFractionalDefCom_D1_SK1(rank, array)
3827 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3828 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_SK1
3829 : #endif
3830 : use pm_kind, only: TKR => RK, SKC => SK1
3831 : character(*,SKC) , intent(in) , contiguous :: array(:)
3832 : real(TKR) , intent(out) , contiguous :: rank(:)
3833 : end subroutine
3834 : #endif
3835 :
3836 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3837 :
3838 : #if IK5_ENABLED
3839 : PURE module subroutine setRankFractionalDefCom_D1_IK5(rank, array)
3840 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3841 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_IK5
3842 : #endif
3843 : use pm_kind, only: TKR => RK, IKC => IK5
3844 : integer(IKC) , intent(in) , contiguous :: array(:)
3845 : real(TKR) , intent(out) , contiguous :: rank(:)
3846 : end subroutine
3847 : #endif
3848 :
3849 : #if IK4_ENABLED
3850 : PURE module subroutine setRankFractionalDefCom_D1_IK4(rank, array)
3851 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3852 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_IK4
3853 : #endif
3854 : use pm_kind, only: TKR => RK, IKC => IK4
3855 : integer(IKC) , intent(in) , contiguous :: array(:)
3856 : real(TKR) , intent(out) , contiguous :: rank(:)
3857 : end subroutine
3858 : #endif
3859 :
3860 : #if IK3_ENABLED
3861 : PURE module subroutine setRankFractionalDefCom_D1_IK3(rank, array)
3862 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3863 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_IK3
3864 : #endif
3865 : use pm_kind, only: TKR => RK, IKC => IK3
3866 : integer(IKC) , intent(in) , contiguous :: array(:)
3867 : real(TKR) , intent(out) , contiguous :: rank(:)
3868 : end subroutine
3869 : #endif
3870 :
3871 : #if IK2_ENABLED
3872 : PURE module subroutine setRankFractionalDefCom_D1_IK2(rank, array)
3873 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3874 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_IK2
3875 : #endif
3876 : use pm_kind, only: TKR => RK, IKC => IK2
3877 : integer(IKC) , intent(in) , contiguous :: array(:)
3878 : real(TKR) , intent(out) , contiguous :: rank(:)
3879 : end subroutine
3880 : #endif
3881 :
3882 : #if IK1_ENABLED
3883 : PURE module subroutine setRankFractionalDefCom_D1_IK1(rank, array)
3884 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3885 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_IK1
3886 : #endif
3887 : use pm_kind, only: TKR => RK, IKC => IK1
3888 : integer(IKC) , intent(in) , contiguous :: array(:)
3889 : real(TKR) , intent(out) , contiguous :: rank(:)
3890 : end subroutine
3891 : #endif
3892 :
3893 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3894 :
3895 : #if LK5_ENABLED
3896 : PURE module subroutine setRankFractionalDefCom_D1_LK5(rank, array)
3897 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3898 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_LK5
3899 : #endif
3900 : use pm_kind, only: TKR => RK, LKC => LK5
3901 : logical(LKC) , intent(in) , contiguous :: array(:)
3902 : real(TKR) , intent(out) , contiguous :: rank(:)
3903 : end subroutine
3904 : #endif
3905 :
3906 : #if LK4_ENABLED
3907 : PURE module subroutine setRankFractionalDefCom_D1_LK4(rank, array)
3908 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3909 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_LK4
3910 : #endif
3911 : use pm_kind, only: TKR => RK, LKC => LK4
3912 : logical(LKC) , intent(in) , contiguous :: array(:)
3913 : real(TKR) , intent(out) , contiguous :: rank(:)
3914 : end subroutine
3915 : #endif
3916 :
3917 : #if LK3_ENABLED
3918 : PURE module subroutine setRankFractionalDefCom_D1_LK3(rank, array)
3919 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3920 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_LK3
3921 : #endif
3922 : use pm_kind, only: TKR => RK, LKC => LK3
3923 : logical(LKC) , intent(in) , contiguous :: array(:)
3924 : real(TKR) , intent(out) , contiguous :: rank(:)
3925 : end subroutine
3926 : #endif
3927 :
3928 : #if LK2_ENABLED
3929 : PURE module subroutine setRankFractionalDefCom_D1_LK2(rank, array)
3930 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3931 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_LK2
3932 : #endif
3933 : use pm_kind, only: TKR => RK, LKC => LK2
3934 : logical(LKC) , intent(in) , contiguous :: array(:)
3935 : real(TKR) , intent(out) , contiguous :: rank(:)
3936 : end subroutine
3937 : #endif
3938 :
3939 : #if LK1_ENABLED
3940 : PURE module subroutine setRankFractionalDefCom_D1_LK1(rank, array)
3941 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3942 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_LK1
3943 : #endif
3944 : use pm_kind, only: TKR => RK, LKC => LK1
3945 : logical(LKC) , intent(in) , contiguous :: array(:)
3946 : real(TKR) , intent(out) , contiguous :: rank(:)
3947 : end subroutine
3948 : #endif
3949 :
3950 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3951 :
3952 : #if CK5_ENABLED
3953 : PURE module subroutine setRankFractionalDefCom_D1_CK5(rank, array)
3954 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3955 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_CK5
3956 : #endif
3957 : use pm_kind, only: TKR => RK, CKC => CK5
3958 : complex(CKC) , intent(in) , contiguous :: array(:)
3959 : real(TKR) , intent(out) , contiguous :: rank(:)
3960 : end subroutine
3961 : #endif
3962 :
3963 : #if CK4_ENABLED
3964 : PURE module subroutine setRankFractionalDefCom_D1_CK4(rank, array)
3965 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3966 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_CK4
3967 : #endif
3968 : use pm_kind, only: TKR => RK, CKC => CK4
3969 : complex(CKC) , intent(in) , contiguous :: array(:)
3970 : real(TKR) , intent(out) , contiguous :: rank(:)
3971 : end subroutine
3972 : #endif
3973 :
3974 : #if CK3_ENABLED
3975 : PURE module subroutine setRankFractionalDefCom_D1_CK3(rank, array)
3976 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3977 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_CK3
3978 : #endif
3979 : use pm_kind, only: TKR => RK, CKC => CK3
3980 : complex(CKC) , intent(in) , contiguous :: array(:)
3981 : real(TKR) , intent(out) , contiguous :: rank(:)
3982 : end subroutine
3983 : #endif
3984 :
3985 : #if CK2_ENABLED
3986 : PURE module subroutine setRankFractionalDefCom_D1_CK2(rank, array)
3987 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3988 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_CK2
3989 : #endif
3990 : use pm_kind, only: TKR => RK, CKC => CK2
3991 : complex(CKC) , intent(in) , contiguous :: array(:)
3992 : real(TKR) , intent(out) , contiguous :: rank(:)
3993 : end subroutine
3994 : #endif
3995 :
3996 : #if CK1_ENABLED
3997 : PURE module subroutine setRankFractionalDefCom_D1_CK1(rank, array)
3998 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3999 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_CK1
4000 : #endif
4001 : use pm_kind, only: TKR => RK, CKC => CK1
4002 : complex(CKC) , intent(in) , contiguous :: array(:)
4003 : real(TKR) , intent(out) , contiguous :: rank(:)
4004 : end subroutine
4005 : #endif
4006 :
4007 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4008 :
4009 : #if RK5_ENABLED
4010 : PURE module subroutine setRankFractionalDefCom_D1_RK5(rank, array)
4011 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4012 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_RK5
4013 : #endif
4014 : use pm_kind, only: TKR => RK, RKC => RK5
4015 : real(RKC) , intent(in) , contiguous :: array(:)
4016 : real(TKR) , intent(out) , contiguous :: rank(:)
4017 : end subroutine
4018 : #endif
4019 :
4020 : #if RK4_ENABLED
4021 : PURE module subroutine setRankFractionalDefCom_D1_RK4(rank, array)
4022 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4023 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_RK4
4024 : #endif
4025 : use pm_kind, only: TKR => RK, RKC => RK4
4026 : real(RKC) , intent(in) , contiguous :: array(:)
4027 : real(TKR) , intent(out) , contiguous :: rank(:)
4028 : end subroutine
4029 : #endif
4030 :
4031 : #if RK3_ENABLED
4032 : PURE module subroutine setRankFractionalDefCom_D1_RK3(rank, array)
4033 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4034 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_RK3
4035 : #endif
4036 : use pm_kind, only: TKR => RK, RKC => RK3
4037 : real(RKC) , intent(in) , contiguous :: array(:)
4038 : real(TKR) , intent(out) , contiguous :: rank(:)
4039 : end subroutine
4040 : #endif
4041 :
4042 : #if RK2_ENABLED
4043 : PURE module subroutine setRankFractionalDefCom_D1_RK2(rank, array)
4044 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4045 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_RK2
4046 : #endif
4047 : use pm_kind, only: TKR => RK, RKC => RK2
4048 : real(RKC) , intent(in) , contiguous :: array(:)
4049 : real(TKR) , intent(out) , contiguous :: rank(:)
4050 : end subroutine
4051 : #endif
4052 :
4053 : #if RK1_ENABLED
4054 : PURE module subroutine setRankFractionalDefCom_D1_RK1(rank, array)
4055 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4056 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_RK1
4057 : #endif
4058 : use pm_kind, only: TKR => RK, RKC => RK1
4059 : real(RKC) , intent(in) , contiguous :: array(:)
4060 : real(TKR) , intent(out) , contiguous :: rank(:)
4061 : end subroutine
4062 : #endif
4063 :
4064 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4065 :
4066 : #if SK5_ENABLED
4067 : PURE module subroutine setRankFractionalDefCom_D1_PSSK5(rank, array)
4068 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4069 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_PSSK5
4070 : #endif
4071 : use pm_kind, only: TKR => RK, SKC => SK5
4072 : use pm_container, only: css_pdt
4073 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4074 : real(TKR) , intent(out) , contiguous :: rank(:)
4075 : end subroutine
4076 : #endif
4077 :
4078 : #if SK4_ENABLED
4079 : PURE module subroutine setRankFractionalDefCom_D1_PSSK4(rank, array)
4080 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4081 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_PSSK4
4082 : #endif
4083 : use pm_kind, only: TKR => RK, SKC => SK4
4084 : use pm_container, only: css_pdt
4085 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4086 : real(TKR) , intent(out) , contiguous :: rank(:)
4087 : end subroutine
4088 : #endif
4089 :
4090 : #if SK3_ENABLED
4091 : PURE module subroutine setRankFractionalDefCom_D1_PSSK3(rank, array)
4092 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4093 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_PSSK3
4094 : #endif
4095 : use pm_kind, only: TKR => RK, SKC => SK3
4096 : use pm_container, only: css_pdt
4097 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4098 : real(TKR) , intent(out) , contiguous :: rank(:)
4099 : end subroutine
4100 : #endif
4101 :
4102 : #if SK2_ENABLED
4103 : PURE module subroutine setRankFractionalDefCom_D1_PSSK2(rank, array)
4104 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4105 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_PSSK2
4106 : #endif
4107 : use pm_kind, only: TKR => RK, SKC => SK2
4108 : use pm_container, only: css_pdt
4109 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4110 : real(TKR) , intent(out) , contiguous :: rank(:)
4111 : end subroutine
4112 : #endif
4113 :
4114 : #if SK1_ENABLED
4115 : PURE module subroutine setRankFractionalDefCom_D1_PSSK1(rank, array)
4116 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4117 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_PSSK1
4118 : #endif
4119 : use pm_kind, only: TKR => RK, SKC => SK1
4120 : use pm_container, only: css_pdt
4121 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4122 : real(TKR) , intent(out) , contiguous :: rank(:)
4123 : end subroutine
4124 : #endif
4125 :
4126 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4127 :
4128 : PURE module subroutine setRankFractionalDefCom_D1_BSSK(rank, array)
4129 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4130 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalDefCom_D1_BSSK
4131 : #endif
4132 : use pm_kind, only: TKR => RK, SKC => SK
4133 : use pm_container, only: css_type
4134 : type(css_type) , intent(in) , contiguous :: array(:)
4135 : real(TKR) , intent(out) , contiguous :: rank(:)
4136 : end subroutine
4137 :
4138 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4139 :
4140 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4141 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4142 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4143 :
4144 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4145 :
4146 : #if SK5_ENABLED
4147 : module subroutine setRankFractionalCusCom_D0_SK5(rank, array, isSorted)
4148 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4149 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D0_SK5
4150 : #endif
4151 : use pm_kind, only: TKR => RK, SKC => SK5
4152 : character(*,SKC) , intent(in) :: array
4153 : real(TKR) , intent(out) , contiguous :: rank(:)
4154 : procedure(logical(LK)) :: isSorted
4155 : end subroutine
4156 : #endif
4157 :
4158 : #if SK4_ENABLED
4159 : module subroutine setRankFractionalCusCom_D0_SK4(rank, array, isSorted)
4160 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4161 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D0_SK4
4162 : #endif
4163 : use pm_kind, only: TKR => RK, SKC => SK4
4164 : character(*,SKC) , intent(in) :: array
4165 : real(TKR) , intent(out) , contiguous :: rank(:)
4166 : procedure(logical(LK)) :: isSorted
4167 : end subroutine
4168 : #endif
4169 :
4170 : #if SK3_ENABLED
4171 : module subroutine setRankFractionalCusCom_D0_SK3(rank, array, isSorted)
4172 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4173 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D0_SK3
4174 : #endif
4175 : use pm_kind, only: TKR => RK, SKC => SK3
4176 : character(*,SKC) , intent(in) :: array
4177 : real(TKR) , intent(out) , contiguous :: rank(:)
4178 : procedure(logical(LK)) :: isSorted
4179 : end subroutine
4180 : #endif
4181 :
4182 : #if SK2_ENABLED
4183 : module subroutine setRankFractionalCusCom_D0_SK2(rank, array, isSorted)
4184 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4185 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D0_SK2
4186 : #endif
4187 : use pm_kind, only: TKR => RK, SKC => SK2
4188 : character(*,SKC) , intent(in) :: array
4189 : real(TKR) , intent(out) , contiguous :: rank(:)
4190 : procedure(logical(LK)) :: isSorted
4191 : end subroutine
4192 : #endif
4193 :
4194 : #if SK1_ENABLED
4195 : module subroutine setRankFractionalCusCom_D0_SK1(rank, array, isSorted)
4196 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4197 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D0_SK1
4198 : #endif
4199 : use pm_kind, only: TKR => RK, SKC => SK1
4200 : character(*,SKC) , intent(in) :: array
4201 : real(TKR) , intent(out) , contiguous :: rank(:)
4202 : procedure(logical(LK)) :: isSorted
4203 : end subroutine
4204 : #endif
4205 :
4206 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4207 :
4208 : #if SK5_ENABLED
4209 : module subroutine setRankFractionalCusCom_D1_SK5(rank, array, isSorted)
4210 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4211 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_SK5
4212 : #endif
4213 : use pm_kind, only: TKR => RK, SKC => SK5
4214 : character(*,SKC) , intent(in) , contiguous :: array(:)
4215 : real(TKR) , intent(out) , contiguous :: rank(:)
4216 : procedure(logical(LK)) :: isSorted
4217 : end subroutine
4218 : #endif
4219 :
4220 : #if SK4_ENABLED
4221 : module subroutine setRankFractionalCusCom_D1_SK4(rank, array, isSorted)
4222 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4223 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_SK4
4224 : #endif
4225 : use pm_kind, only: TKR => RK, SKC => SK4
4226 : character(*,SKC) , intent(in) , contiguous :: array(:)
4227 : real(TKR) , intent(out) , contiguous :: rank(:)
4228 : procedure(logical(LK)) :: isSorted
4229 : end subroutine
4230 : #endif
4231 :
4232 : #if SK3_ENABLED
4233 : module subroutine setRankFractionalCusCom_D1_SK3(rank, array, isSorted)
4234 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4235 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_SK3
4236 : #endif
4237 : use pm_kind, only: TKR => RK, SKC => SK3
4238 : character(*,SKC) , intent(in) , contiguous :: array(:)
4239 : real(TKR) , intent(out) , contiguous :: rank(:)
4240 : procedure(logical(LK)) :: isSorted
4241 : end subroutine
4242 : #endif
4243 :
4244 : #if SK2_ENABLED
4245 : module subroutine setRankFractionalCusCom_D1_SK2(rank, array, isSorted)
4246 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4247 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_SK2
4248 : #endif
4249 : use pm_kind, only: TKR => RK, SKC => SK2
4250 : character(*,SKC) , intent(in) , contiguous :: array(:)
4251 : real(TKR) , intent(out) , contiguous :: rank(:)
4252 : procedure(logical(LK)) :: isSorted
4253 : end subroutine
4254 : #endif
4255 :
4256 : #if SK1_ENABLED
4257 : module subroutine setRankFractionalCusCom_D1_SK1(rank, array, isSorted)
4258 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4259 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_SK1
4260 : #endif
4261 : use pm_kind, only: TKR => RK, SKC => SK1
4262 : character(*,SKC) , intent(in) , contiguous :: array(:)
4263 : real(TKR) , intent(out) , contiguous :: rank(:)
4264 : procedure(logical(LK)) :: isSorted
4265 : end subroutine
4266 : #endif
4267 :
4268 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4269 :
4270 : #if IK5_ENABLED
4271 : module subroutine setRankFractionalCusCom_D1_IK5(rank, array, isSorted)
4272 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4273 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_IK5
4274 : #endif
4275 : use pm_kind, only: TKR => RK, IKC => IK5
4276 : integer(IKC) , intent(in) , contiguous :: array(:)
4277 : real(TKR) , intent(out) , contiguous :: rank(:)
4278 : procedure(logical(LK)) :: isSorted
4279 : end subroutine
4280 : #endif
4281 :
4282 : #if IK4_ENABLED
4283 : module subroutine setRankFractionalCusCom_D1_IK4(rank, array, isSorted)
4284 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4285 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_IK4
4286 : #endif
4287 : use pm_kind, only: TKR => RK, IKC => IK4
4288 : integer(IKC) , intent(in) , contiguous :: array(:)
4289 : real(TKR) , intent(out) , contiguous :: rank(:)
4290 : procedure(logical(LK)) :: isSorted
4291 : end subroutine
4292 : #endif
4293 :
4294 : #if IK3_ENABLED
4295 : module subroutine setRankFractionalCusCom_D1_IK3(rank, array, isSorted)
4296 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4297 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_IK3
4298 : #endif
4299 : use pm_kind, only: TKR => RK, IKC => IK3
4300 : integer(IKC) , intent(in) , contiguous :: array(:)
4301 : real(TKR) , intent(out) , contiguous :: rank(:)
4302 : procedure(logical(LK)) :: isSorted
4303 : end subroutine
4304 : #endif
4305 :
4306 : #if IK2_ENABLED
4307 : module subroutine setRankFractionalCusCom_D1_IK2(rank, array, isSorted)
4308 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4309 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_IK2
4310 : #endif
4311 : use pm_kind, only: TKR => RK, IKC => IK2
4312 : integer(IKC) , intent(in) , contiguous :: array(:)
4313 : real(TKR) , intent(out) , contiguous :: rank(:)
4314 : procedure(logical(LK)) :: isSorted
4315 : end subroutine
4316 : #endif
4317 :
4318 : #if IK1_ENABLED
4319 : module subroutine setRankFractionalCusCom_D1_IK1(rank, array, isSorted)
4320 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4321 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_IK1
4322 : #endif
4323 : use pm_kind, only: TKR => RK, IKC => IK1
4324 : integer(IKC) , intent(in) , contiguous :: array(:)
4325 : real(TKR) , intent(out) , contiguous :: rank(:)
4326 : procedure(logical(LK)) :: isSorted
4327 : end subroutine
4328 : #endif
4329 :
4330 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4331 :
4332 : #if LK5_ENABLED
4333 : module subroutine setRankFractionalCusCom_D1_LK5(rank, array, isSorted)
4334 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4335 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_LK5
4336 : #endif
4337 : use pm_kind, only: TKR => RK, LKC => LK5
4338 : logical(LKC) , intent(in) , contiguous :: array(:)
4339 : real(TKR) , intent(out) , contiguous :: rank(:)
4340 : procedure(logical(LK)) :: isSorted
4341 : end subroutine
4342 : #endif
4343 :
4344 : #if LK4_ENABLED
4345 : module subroutine setRankFractionalCusCom_D1_LK4(rank, array, isSorted)
4346 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4347 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_LK4
4348 : #endif
4349 : use pm_kind, only: TKR => RK, LKC => LK4
4350 : logical(LKC) , intent(in) , contiguous :: array(:)
4351 : real(TKR) , intent(out) , contiguous :: rank(:)
4352 : procedure(logical(LK)) :: isSorted
4353 : end subroutine
4354 : #endif
4355 :
4356 : #if LK3_ENABLED
4357 : module subroutine setRankFractionalCusCom_D1_LK3(rank, array, isSorted)
4358 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4359 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_LK3
4360 : #endif
4361 : use pm_kind, only: TKR => RK, LKC => LK3
4362 : logical(LKC) , intent(in) , contiguous :: array(:)
4363 : real(TKR) , intent(out) , contiguous :: rank(:)
4364 : procedure(logical(LK)) :: isSorted
4365 : end subroutine
4366 : #endif
4367 :
4368 : #if LK2_ENABLED
4369 : module subroutine setRankFractionalCusCom_D1_LK2(rank, array, isSorted)
4370 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4371 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_LK2
4372 : #endif
4373 : use pm_kind, only: TKR => RK, LKC => LK2
4374 : logical(LKC) , intent(in) , contiguous :: array(:)
4375 : real(TKR) , intent(out) , contiguous :: rank(:)
4376 : procedure(logical(LK)) :: isSorted
4377 : end subroutine
4378 : #endif
4379 :
4380 : #if LK1_ENABLED
4381 : module subroutine setRankFractionalCusCom_D1_LK1(rank, array, isSorted)
4382 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4383 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_LK1
4384 : #endif
4385 : use pm_kind, only: TKR => RK, LKC => LK1
4386 : logical(LKC) , intent(in) , contiguous :: array(:)
4387 : real(TKR) , intent(out) , contiguous :: rank(:)
4388 : procedure(logical(LK)) :: isSorted
4389 : end subroutine
4390 : #endif
4391 :
4392 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4393 :
4394 : #if CK5_ENABLED
4395 : module subroutine setRankFractionalCusCom_D1_CK5(rank, array, isSorted)
4396 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4397 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_CK5
4398 : #endif
4399 : use pm_kind, only: TKR => RK, CKC => CK5
4400 : complex(CKC) , intent(in) , contiguous :: array(:)
4401 : real(TKR) , intent(out) , contiguous :: rank(:)
4402 : procedure(logical(LK)) :: isSorted
4403 : end subroutine
4404 : #endif
4405 :
4406 : #if CK4_ENABLED
4407 : module subroutine setRankFractionalCusCom_D1_CK4(rank, array, isSorted)
4408 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4409 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_CK4
4410 : #endif
4411 : use pm_kind, only: TKR => RK, CKC => CK4
4412 : complex(CKC) , intent(in) , contiguous :: array(:)
4413 : real(TKR) , intent(out) , contiguous :: rank(:)
4414 : procedure(logical(LK)) :: isSorted
4415 : end subroutine
4416 : #endif
4417 :
4418 : #if CK3_ENABLED
4419 : module subroutine setRankFractionalCusCom_D1_CK3(rank, array, isSorted)
4420 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4421 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_CK3
4422 : #endif
4423 : use pm_kind, only: TKR => RK, CKC => CK3
4424 : complex(CKC) , intent(in) , contiguous :: array(:)
4425 : real(TKR) , intent(out) , contiguous :: rank(:)
4426 : procedure(logical(LK)) :: isSorted
4427 : end subroutine
4428 : #endif
4429 :
4430 : #if CK2_ENABLED
4431 : module subroutine setRankFractionalCusCom_D1_CK2(rank, array, isSorted)
4432 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4433 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_CK2
4434 : #endif
4435 : use pm_kind, only: TKR => RK, CKC => CK2
4436 : complex(CKC) , intent(in) , contiguous :: array(:)
4437 : real(TKR) , intent(out) , contiguous :: rank(:)
4438 : procedure(logical(LK)) :: isSorted
4439 : end subroutine
4440 : #endif
4441 :
4442 : #if CK1_ENABLED
4443 : module subroutine setRankFractionalCusCom_D1_CK1(rank, array, isSorted)
4444 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4445 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_CK1
4446 : #endif
4447 : use pm_kind, only: TKR => RK, CKC => CK1
4448 : complex(CKC) , intent(in) , contiguous :: array(:)
4449 : real(TKR) , intent(out) , contiguous :: rank(:)
4450 : procedure(logical(LK)) :: isSorted
4451 : end subroutine
4452 : #endif
4453 :
4454 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4455 :
4456 : #if RK5_ENABLED
4457 : module subroutine setRankFractionalCusCom_D1_RK5(rank, array, isSorted)
4458 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4459 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_RK5
4460 : #endif
4461 : use pm_kind, only: TKR => RK, RKC => RK5
4462 : real(RKC) , intent(in) , contiguous :: array(:)
4463 : real(TKR) , intent(out) , contiguous :: rank(:)
4464 : procedure(logical(LK)) :: isSorted
4465 : end subroutine
4466 : #endif
4467 :
4468 : #if RK4_ENABLED
4469 : module subroutine setRankFractionalCusCom_D1_RK4(rank, array, isSorted)
4470 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4471 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_RK4
4472 : #endif
4473 : use pm_kind, only: TKR => RK, RKC => RK4
4474 : real(RKC) , intent(in) , contiguous :: array(:)
4475 : real(TKR) , intent(out) , contiguous :: rank(:)
4476 : procedure(logical(LK)) :: isSorted
4477 : end subroutine
4478 : #endif
4479 :
4480 : #if RK3_ENABLED
4481 : module subroutine setRankFractionalCusCom_D1_RK3(rank, array, isSorted)
4482 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4483 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_RK3
4484 : #endif
4485 : use pm_kind, only: TKR => RK, RKC => RK3
4486 : real(RKC) , intent(in) , contiguous :: array(:)
4487 : real(TKR) , intent(out) , contiguous :: rank(:)
4488 : procedure(logical(LK)) :: isSorted
4489 : end subroutine
4490 : #endif
4491 :
4492 : #if RK2_ENABLED
4493 : module subroutine setRankFractionalCusCom_D1_RK2(rank, array, isSorted)
4494 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4495 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_RK2
4496 : #endif
4497 : use pm_kind, only: TKR => RK, RKC => RK2
4498 : real(RKC) , intent(in) , contiguous :: array(:)
4499 : real(TKR) , intent(out) , contiguous :: rank(:)
4500 : procedure(logical(LK)) :: isSorted
4501 : end subroutine
4502 : #endif
4503 :
4504 : #if RK1_ENABLED
4505 : module subroutine setRankFractionalCusCom_D1_RK1(rank, array, isSorted)
4506 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4507 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_RK1
4508 : #endif
4509 : use pm_kind, only: TKR => RK, RKC => RK1
4510 : real(RKC) , intent(in) , contiguous :: array(:)
4511 : real(TKR) , intent(out) , contiguous :: rank(:)
4512 : procedure(logical(LK)) :: isSorted
4513 : end subroutine
4514 : #endif
4515 :
4516 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4517 :
4518 : #if SK5_ENABLED
4519 : module subroutine setRankFractionalCusCom_D1_PSSK5(rank, array, isSorted)
4520 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4521 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_PSSK5
4522 : #endif
4523 : use pm_kind, only: TKR => RK, SKC => SK5
4524 : use pm_container, only: css_pdt
4525 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4526 : real(TKR) , intent(out) , contiguous :: rank(:)
4527 : procedure(logical(LK)) :: isSorted
4528 : end subroutine
4529 : #endif
4530 :
4531 : #if SK4_ENABLED
4532 : module subroutine setRankFractionalCusCom_D1_PSSK4(rank, array, isSorted)
4533 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4534 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_PSSK4
4535 : #endif
4536 : use pm_kind, only: TKR => RK, SKC => SK4
4537 : use pm_container, only: css_pdt
4538 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4539 : real(TKR) , intent(out) , contiguous :: rank(:)
4540 : procedure(logical(LK)) :: isSorted
4541 : end subroutine
4542 : #endif
4543 :
4544 : #if SK3_ENABLED
4545 : module subroutine setRankFractionalCusCom_D1_PSSK3(rank, array, isSorted)
4546 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4547 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_PSSK3
4548 : #endif
4549 : use pm_kind, only: TKR => RK, SKC => SK3
4550 : use pm_container, only: css_pdt
4551 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4552 : real(TKR) , intent(out) , contiguous :: rank(:)
4553 : procedure(logical(LK)) :: isSorted
4554 : end subroutine
4555 : #endif
4556 :
4557 : #if SK2_ENABLED
4558 : module subroutine setRankFractionalCusCom_D1_PSSK2(rank, array, isSorted)
4559 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4560 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_PSSK2
4561 : #endif
4562 : use pm_kind, only: TKR => RK, SKC => SK2
4563 : use pm_container, only: css_pdt
4564 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4565 : real(TKR) , intent(out) , contiguous :: rank(:)
4566 : procedure(logical(LK)) :: isSorted
4567 : end subroutine
4568 : #endif
4569 :
4570 : #if SK1_ENABLED
4571 : module subroutine setRankFractionalCusCom_D1_PSSK1(rank, array, isSorted)
4572 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4573 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_PSSK1
4574 : #endif
4575 : use pm_kind, only: TKR => RK, SKC => SK1
4576 : use pm_container, only: css_pdt
4577 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
4578 : real(TKR) , intent(out) , contiguous :: rank(:)
4579 : procedure(logical(LK)) :: isSorted
4580 : end subroutine
4581 : #endif
4582 :
4583 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4584 :
4585 : module subroutine setRankFractionalCusCom_D1_BSSK(rank, array, isSorted)
4586 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4587 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankFractionalCusCom_D1_BSSK
4588 : #endif
4589 : use pm_kind, only: TKR => RK, SKC => SK
4590 : use pm_container, only: css_type
4591 : type(css_type) , intent(in) , contiguous :: array(:)
4592 : real(TKR) , intent(out) , contiguous :: rank(:)
4593 : procedure(logical(LK)) :: isSorted
4594 : end subroutine
4595 :
4596 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4597 :
4598 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4599 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4600 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4601 :
4602 : end interface
4603 :
4604 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4605 :
4606 : !> \brief
4607 : !> Generate and return the **Modified rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
4608 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
4609 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
4610 : !>
4611 : !> \details
4612 : !> This kind of ranking of values is widely known as <b>Modified Competition (`1334`) ranking</b>.<br>
4613 : !> Sometimes, competition ranking is done by leaving the gaps in the ranking numbers before the sets
4614 : !> of equal-ranking items (rather than after them as in Standard Competition ranking).<br>
4615 : !> The number of ranking numbers that are left out in this gap remains one less than the number of items that compared equal.<br>
4616 : !> Equivalently, the ranking number of each item is equal to the number of items ranked equal to it or above it.<br>
4617 : !> This ranking ensures that a competitor only comes second if they score higher than all but one of their opponents,
4618 : !> third if they score higher than all but two of their opponents, etc.<br>
4619 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked head of *D*, then *A* gets ranking
4620 : !> number `1` (*first*), *B* gets ranking number `3` (*joint third*), *C* also gets ranking number `3` (*joint third*)
4621 : !> and *D* gets ranking number `4` (*fourth*).<br>
4622 : !> In this case, nobody would get ranking number `2` (*second*) (left as a gap).<br>
4623 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Modified Competition ranking** `1334`.<br>
4624 : !>
4625 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
4626 : !> <ol>
4627 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
4628 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
4629 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
4630 : !> <li> type `integer` of kind \IKALL or,<br>
4631 : !> <li> type `logical` of kind \LKALL or,<br>
4632 : !> <li> type `complex` of kind \CKALL or,<br>
4633 : !> <li> type `real` of kind \RKALL,<br>
4634 : !> </ol>
4635 : !> or,
4636 : !> <ol>
4637 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
4638 : !> </ol>
4639 : !> whose elements rankings will be computed and returned.
4640 : !> \param[out] rank : The output `contiguous` array of rank `1` of type `integer` of default kind \IK
4641 : !> containing the ranks of the corresponding elements of `array`.<br>
4642 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
4643 : !> **Read `rank(i)` as the Modified rank of the `i`th element of `array`.**
4644 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type
4645 : !> and kind as the input `array`.<br>
4646 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
4647 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
4648 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
4649 : !> If `array` is a Fortran string (i.e., a scalar `character`),
4650 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
4651 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
4652 : !> \code{.F90}
4653 : !> function isSorted(a,b) result (sorted)
4654 : !> use pm_kind, only: SK, IK, LK, CK, RK
4655 : !> TYPE(KIND) , intent(in) :: a, b
4656 : !> logical(LK) :: sorted
4657 : !> end function
4658 : !> \endcode
4659 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
4660 : !> \code{.F90}
4661 : !> use pm_container, only: StrCon
4662 : !> use pm_kind, only: SK, IK, LK, CK, RK
4663 : !> character(*, SK), intent(in) :: a, b
4664 : !> integer(IK) , intent(in) :: a, b
4665 : !> logical(LK) , intent(in) :: a, b
4666 : !> complex(CK) , intent(in) :: a, b
4667 : !> real(RK) , intent(in) :: a, b
4668 : !> type(StrCon) , intent(in) :: a, b
4669 : !> \endcode
4670 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
4671 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
4672 : !> \code{.F90}
4673 : !> function isSorted(a,b) result (sorted)
4674 : !> character(1,SKC), intent(in) :: a, b
4675 : !> logical(LK) :: sorted
4676 : !> end function
4677 : !> \endcode
4678 : !> where `SKC` represents the kind of the input string argument `array`.<br>
4679 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
4680 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
4681 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
4682 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
4683 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
4684 : !>
4685 : !> \return
4686 : !> `rank(1:size(array)` : The output `contiguous` array of rank `1` of type `integer` of default kind \IK containing the ranks of the corresponding elements of `array`.<br>
4687 : !> The size of `rank` matches that of `array` (or its length type parameter if `array` is a scalar string).<br>
4688 : !> **Read `rank(i)` as the Modified rank of the `i`th element of `array`.**
4689 : !>
4690 : !> \interface{getRankModified}
4691 : !> \code{.F90}
4692 : !>
4693 : !> use pm_arrayRank, only: getRankModified
4694 : !>
4695 : !> rank(1:size(array)) = getRankModified(array)
4696 : !> rank(1:size(array)) = getRankModified(array, isSorted)
4697 : !>
4698 : !> \endcode
4699 : !>
4700 : !> \warning
4701 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
4702 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
4703 : !> identify ties within the Modified ranking of the input `array`.
4704 : !>
4705 : !> \warnpure
4706 : !>
4707 : !> \warning
4708 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
4709 : !>
4710 : !> \see
4711 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
4712 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
4713 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
4714 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
4715 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
4716 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
4717 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
4718 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
4719 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
4720 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
4721 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
4722 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
4723 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
4724 : !>
4725 : !> \example{getRankModified}
4726 : !> \include{lineno} example/pm_arrayRank/getRankModified/main.F90
4727 : !> \compilef{getRankModified}
4728 : !> \output{getRankModified}
4729 : !> \include{lineno} example/pm_arrayRank/getRankModified/main.out.F90
4730 : !>
4731 : !> \test
4732 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
4733 : !>
4734 : !> \bug
4735 : !> \status \unresolved
4736 : !> \source \ifort{2021.5}
4737 : !> \desc
4738 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
4739 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
4740 : !> \remedy
4741 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
4742 : !>
4743 : !> \todo
4744 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
4745 : !>
4746 : !> \todo
4747 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
4748 : !>
4749 : !> \finmain{getRankModified}
4750 : !>
4751 : !> \author
4752 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
4753 : interface getRankModified
4754 :
4755 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4756 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4757 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4758 :
4759 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4760 :
4761 : #if SK5_ENABLED
4762 : module function getRankModifiedDefCom_D0_SK5(array) result(rank)
4763 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4764 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D0_SK5
4765 : #endif
4766 : use pm_kind, only: TKR => IK, SKC => SK5
4767 : character(*,SKC) , intent(in) :: array
4768 : integer(TKR) :: rank(len(array, IK))
4769 : end function
4770 : #endif
4771 :
4772 : #if SK4_ENABLED
4773 : module function getRankModifiedDefCom_D0_SK4(array) result(rank)
4774 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4775 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D0_SK4
4776 : #endif
4777 : use pm_kind, only: TKR => IK, SKC => SK4
4778 : character(*,SKC) , intent(in) :: array
4779 : integer(TKR) :: rank(len(array, IK))
4780 : end function
4781 : #endif
4782 :
4783 : #if SK3_ENABLED
4784 : module function getRankModifiedDefCom_D0_SK3(array) result(rank)
4785 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4786 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D0_SK3
4787 : #endif
4788 : use pm_kind, only: TKR => IK, SKC => SK3
4789 : character(*,SKC) , intent(in) :: array
4790 : integer(TKR) :: rank(len(array, IK))
4791 : end function
4792 : #endif
4793 :
4794 : #if SK2_ENABLED
4795 : module function getRankModifiedDefCom_D0_SK2(array) result(rank)
4796 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4797 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D0_SK2
4798 : #endif
4799 : use pm_kind, only: TKR => IK, SKC => SK2
4800 : character(*,SKC) , intent(in) :: array
4801 : integer(TKR) :: rank(len(array, IK))
4802 : end function
4803 : #endif
4804 :
4805 : #if SK1_ENABLED
4806 : module function getRankModifiedDefCom_D0_SK1(array) result(rank)
4807 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4808 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D0_SK1
4809 : #endif
4810 : use pm_kind, only: TKR => IK, SKC => SK1
4811 : character(*,SKC) , intent(in) :: array
4812 : integer(TKR) :: rank(len(array, IK))
4813 : end function
4814 : #endif
4815 :
4816 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4817 :
4818 : #if SK5_ENABLED
4819 : module function getRankModifiedDefCom_D1_SK5(array) result(rank)
4820 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4821 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_SK5
4822 : #endif
4823 : use pm_kind, only: TKR => IK, SKC => SK5
4824 : character(*,SKC) , intent(in) , contiguous :: array(:)
4825 : integer(TKR) :: rank(size(array, kind = IK))
4826 : end function
4827 : #endif
4828 :
4829 : #if SK4_ENABLED
4830 : module function getRankModifiedDefCom_D1_SK4(array) result(rank)
4831 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4832 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_SK4
4833 : #endif
4834 : use pm_kind, only: TKR => IK, SKC => SK4
4835 : character(*,SKC) , intent(in) , contiguous :: array(:)
4836 : integer(TKR) :: rank(size(array, kind = IK))
4837 : end function
4838 : #endif
4839 :
4840 : #if SK3_ENABLED
4841 : module function getRankModifiedDefCom_D1_SK3(array) result(rank)
4842 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4843 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_SK3
4844 : #endif
4845 : use pm_kind, only: TKR => IK, SKC => SK3
4846 : character(*,SKC) , intent(in) , contiguous :: array(:)
4847 : integer(TKR) :: rank(size(array, kind = IK))
4848 : end function
4849 : #endif
4850 :
4851 : #if SK2_ENABLED
4852 : module function getRankModifiedDefCom_D1_SK2(array) result(rank)
4853 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4854 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_SK2
4855 : #endif
4856 : use pm_kind, only: TKR => IK, SKC => SK2
4857 : character(*,SKC) , intent(in) , contiguous :: array(:)
4858 : integer(TKR) :: rank(size(array, kind = IK))
4859 : end function
4860 : #endif
4861 :
4862 : #if SK1_ENABLED
4863 : module function getRankModifiedDefCom_D1_SK1(array) result(rank)
4864 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4865 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_SK1
4866 : #endif
4867 : use pm_kind, only: TKR => IK, SKC => SK1
4868 : character(*,SKC) , intent(in) , contiguous :: array(:)
4869 : integer(TKR) :: rank(size(array, kind = IK))
4870 : end function
4871 : #endif
4872 :
4873 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4874 :
4875 : #if IK5_ENABLED
4876 : module function getRankModifiedDefCom_D1_IK5(array) result(rank)
4877 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4878 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_IK5
4879 : #endif
4880 : use pm_kind, only: TKR => IK, IKC => IK5
4881 : integer(IKC) , intent(in) , contiguous :: array(:)
4882 : integer(TKR) :: rank(size(array, kind = IK))
4883 : end function
4884 : #endif
4885 :
4886 : #if IK4_ENABLED
4887 : module function getRankModifiedDefCom_D1_IK4(array) result(rank)
4888 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4889 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_IK4
4890 : #endif
4891 : use pm_kind, only: TKR => IK, IKC => IK4
4892 : integer(IKC) , intent(in) , contiguous :: array(:)
4893 : integer(TKR) :: rank(size(array, kind = IK))
4894 : end function
4895 : #endif
4896 :
4897 : #if IK3_ENABLED
4898 : module function getRankModifiedDefCom_D1_IK3(array) result(rank)
4899 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4900 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_IK3
4901 : #endif
4902 : use pm_kind, only: TKR => IK, IKC => IK3
4903 : integer(IKC) , intent(in) , contiguous :: array(:)
4904 : integer(TKR) :: rank(size(array, kind = IK))
4905 : end function
4906 : #endif
4907 :
4908 : #if IK2_ENABLED
4909 : module function getRankModifiedDefCom_D1_IK2(array) result(rank)
4910 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4911 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_IK2
4912 : #endif
4913 : use pm_kind, only: TKR => IK, IKC => IK2
4914 : integer(IKC) , intent(in) , contiguous :: array(:)
4915 : integer(TKR) :: rank(size(array, kind = IK))
4916 : end function
4917 : #endif
4918 :
4919 : #if IK1_ENABLED
4920 : module function getRankModifiedDefCom_D1_IK1(array) result(rank)
4921 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4922 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_IK1
4923 : #endif
4924 : use pm_kind, only: TKR => IK, IKC => IK1
4925 : integer(IKC) , intent(in) , contiguous :: array(:)
4926 : integer(TKR) :: rank(size(array, kind = IK))
4927 : end function
4928 : #endif
4929 :
4930 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4931 :
4932 : #if LK5_ENABLED
4933 : module function getRankModifiedDefCom_D1_LK5(array) result(rank)
4934 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4935 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_LK5
4936 : #endif
4937 : use pm_kind, only: TKR => IK, LKC => LK5
4938 : logical(LKC) , intent(in) , contiguous :: array(:)
4939 : integer(TKR) :: rank(size(array, kind = IK))
4940 : end function
4941 : #endif
4942 :
4943 : #if LK4_ENABLED
4944 : module function getRankModifiedDefCom_D1_LK4(array) result(rank)
4945 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4946 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_LK4
4947 : #endif
4948 : use pm_kind, only: TKR => IK, LKC => LK4
4949 : logical(LKC) , intent(in) , contiguous :: array(:)
4950 : integer(TKR) :: rank(size(array, kind = IK))
4951 : end function
4952 : #endif
4953 :
4954 : #if LK3_ENABLED
4955 : module function getRankModifiedDefCom_D1_LK3(array) result(rank)
4956 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4957 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_LK3
4958 : #endif
4959 : use pm_kind, only: TKR => IK, LKC => LK3
4960 : logical(LKC) , intent(in) , contiguous :: array(:)
4961 : integer(TKR) :: rank(size(array, kind = IK))
4962 : end function
4963 : #endif
4964 :
4965 : #if LK2_ENABLED
4966 : module function getRankModifiedDefCom_D1_LK2(array) result(rank)
4967 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4968 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_LK2
4969 : #endif
4970 : use pm_kind, only: TKR => IK, LKC => LK2
4971 : logical(LKC) , intent(in) , contiguous :: array(:)
4972 : integer(TKR) :: rank(size(array, kind = IK))
4973 : end function
4974 : #endif
4975 :
4976 : #if LK1_ENABLED
4977 : module function getRankModifiedDefCom_D1_LK1(array) result(rank)
4978 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4979 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_LK1
4980 : #endif
4981 : use pm_kind, only: TKR => IK, LKC => LK1
4982 : logical(LKC) , intent(in) , contiguous :: array(:)
4983 : integer(TKR) :: rank(size(array, kind = IK))
4984 : end function
4985 : #endif
4986 :
4987 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4988 :
4989 : #if CK5_ENABLED
4990 : module function getRankModifiedDefCom_D1_CK5(array) result(rank)
4991 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4992 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_CK5
4993 : #endif
4994 : use pm_kind, only: TKR => IK, CKC => CK5
4995 : complex(CKC) , intent(in) , contiguous :: array(:)
4996 : integer(TKR) :: rank(size(array, kind = IK))
4997 : end function
4998 : #endif
4999 :
5000 : #if CK4_ENABLED
5001 : module function getRankModifiedDefCom_D1_CK4(array) result(rank)
5002 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5003 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_CK4
5004 : #endif
5005 : use pm_kind, only: TKR => IK, CKC => CK4
5006 : complex(CKC) , intent(in) , contiguous :: array(:)
5007 : integer(TKR) :: rank(size(array, kind = IK))
5008 : end function
5009 : #endif
5010 :
5011 : #if CK3_ENABLED
5012 : module function getRankModifiedDefCom_D1_CK3(array) result(rank)
5013 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5014 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_CK3
5015 : #endif
5016 : use pm_kind, only: TKR => IK, CKC => CK3
5017 : complex(CKC) , intent(in) , contiguous :: array(:)
5018 : integer(TKR) :: rank(size(array, kind = IK))
5019 : end function
5020 : #endif
5021 :
5022 : #if CK2_ENABLED
5023 : module function getRankModifiedDefCom_D1_CK2(array) result(rank)
5024 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5025 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_CK2
5026 : #endif
5027 : use pm_kind, only: TKR => IK, CKC => CK2
5028 : complex(CKC) , intent(in) , contiguous :: array(:)
5029 : integer(TKR) :: rank(size(array, kind = IK))
5030 : end function
5031 : #endif
5032 :
5033 : #if CK1_ENABLED
5034 : module function getRankModifiedDefCom_D1_CK1(array) result(rank)
5035 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5036 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_CK1
5037 : #endif
5038 : use pm_kind, only: TKR => IK, CKC => CK1
5039 : complex(CKC) , intent(in) , contiguous :: array(:)
5040 : integer(TKR) :: rank(size(array, kind = IK))
5041 : end function
5042 : #endif
5043 :
5044 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5045 :
5046 : #if RK5_ENABLED
5047 : module function getRankModifiedDefCom_D1_RK5(array) result(rank)
5048 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5049 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_RK5
5050 : #endif
5051 : use pm_kind, only: TKR => IK, RKC => RK5
5052 : real(RKC) , intent(in) , contiguous :: array(:)
5053 : integer(TKR) :: rank(size(array, kind = IK))
5054 : end function
5055 : #endif
5056 :
5057 : #if RK4_ENABLED
5058 : module function getRankModifiedDefCom_D1_RK4(array) result(rank)
5059 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5060 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_RK4
5061 : #endif
5062 : use pm_kind, only: TKR => IK, RKC => RK4
5063 : real(RKC) , intent(in) , contiguous :: array(:)
5064 : integer(TKR) :: rank(size(array, kind = IK))
5065 : end function
5066 : #endif
5067 :
5068 : #if RK3_ENABLED
5069 : module function getRankModifiedDefCom_D1_RK3(array) result(rank)
5070 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5071 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_RK3
5072 : #endif
5073 : use pm_kind, only: TKR => IK, RKC => RK3
5074 : real(RKC) , intent(in) , contiguous :: array(:)
5075 : integer(TKR) :: rank(size(array, kind = IK))
5076 : end function
5077 : #endif
5078 :
5079 : #if RK2_ENABLED
5080 : module function getRankModifiedDefCom_D1_RK2(array) result(rank)
5081 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5082 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_RK2
5083 : #endif
5084 : use pm_kind, only: TKR => IK, RKC => RK2
5085 : real(RKC) , intent(in) , contiguous :: array(:)
5086 : integer(TKR) :: rank(size(array, kind = IK))
5087 : end function
5088 : #endif
5089 :
5090 : #if RK1_ENABLED
5091 : module function getRankModifiedDefCom_D1_RK1(array) result(rank)
5092 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5093 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_RK1
5094 : #endif
5095 : use pm_kind, only: TKR => IK, RKC => RK1
5096 : real(RKC) , intent(in) , contiguous :: array(:)
5097 : integer(TKR) :: rank(size(array, kind = IK))
5098 : end function
5099 : #endif
5100 :
5101 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5102 :
5103 : #if SK5_ENABLED
5104 : module function getRankModifiedDefCom_D1_PSSK5(array) result(rank)
5105 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5106 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_PSSK5
5107 : #endif
5108 : use pm_kind, only: TKR => IK, SKC => SK5
5109 : use pm_container, only: css_pdt
5110 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5111 : integer(TKR) :: rank(size(array, kind = IK))
5112 : end function
5113 : #endif
5114 :
5115 : #if SK4_ENABLED
5116 : module function getRankModifiedDefCom_D1_PSSK4(array) result(rank)
5117 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5118 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_PSSK4
5119 : #endif
5120 : use pm_kind, only: TKR => IK, SKC => SK4
5121 : use pm_container, only: css_pdt
5122 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5123 : integer(TKR) :: rank(size(array, kind = IK))
5124 : end function
5125 : #endif
5126 :
5127 : #if SK3_ENABLED
5128 : module function getRankModifiedDefCom_D1_PSSK3(array) result(rank)
5129 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5130 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_PSSK3
5131 : #endif
5132 : use pm_kind, only: TKR => IK, SKC => SK3
5133 : use pm_container, only: css_pdt
5134 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5135 : integer(TKR) :: rank(size(array, kind = IK))
5136 : end function
5137 : #endif
5138 :
5139 : #if SK2_ENABLED
5140 : module function getRankModifiedDefCom_D1_PSSK2(array) result(rank)
5141 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5142 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_PSSK2
5143 : #endif
5144 : use pm_kind, only: TKR => IK, SKC => SK2
5145 : use pm_container, only: css_pdt
5146 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5147 : integer(TKR) :: rank(size(array, kind = IK))
5148 : end function
5149 : #endif
5150 :
5151 : #if SK1_ENABLED
5152 : module function getRankModifiedDefCom_D1_PSSK1(array) result(rank)
5153 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5154 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_PSSK1
5155 : #endif
5156 : use pm_kind, only: TKR => IK, SKC => SK1
5157 : use pm_container, only: css_pdt
5158 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5159 : integer(TKR) :: rank(size(array, kind = IK))
5160 : end function
5161 : #endif
5162 :
5163 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5164 :
5165 : module function getRankModifiedDefCom_D1_BSSK(array) result(rank)
5166 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5167 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedDefCom_D1_BSSK
5168 : #endif
5169 : use pm_kind, only: TKR => IK, SKC => SK
5170 : use pm_container, only: css_type
5171 : type(css_type) , intent(in) , contiguous :: array(:)
5172 : integer(TKR) :: rank(size(array, kind = IK))
5173 : end function
5174 :
5175 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5176 :
5177 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5178 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5179 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5180 :
5181 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5182 :
5183 : #if SK5_ENABLED
5184 : module function getRankModifiedCusCom_D0_SK5(array, isSorted) result(rank)
5185 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5186 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D0_SK5
5187 : #endif
5188 : use pm_kind, only: TKR => IK, SKC => SK5
5189 : character(*,SKC) , intent(in) :: array
5190 : procedure(logical(LK)) :: isSorted
5191 : integer(TKR) :: rank(len(array, IK))
5192 : end function
5193 : #endif
5194 :
5195 : #if SK4_ENABLED
5196 : module function getRankModifiedCusCom_D0_SK4(array, isSorted) result(rank)
5197 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5198 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D0_SK4
5199 : #endif
5200 : use pm_kind, only: TKR => IK, SKC => SK4
5201 : character(*,SKC) , intent(in) :: array
5202 : procedure(logical(LK)) :: isSorted
5203 : integer(TKR) :: rank(len(array, IK))
5204 : end function
5205 : #endif
5206 :
5207 : #if SK3_ENABLED
5208 : module function getRankModifiedCusCom_D0_SK3(array, isSorted) result(rank)
5209 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5210 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D0_SK3
5211 : #endif
5212 : use pm_kind, only: TKR => IK, SKC => SK3
5213 : character(*,SKC) , intent(in) :: array
5214 : procedure(logical(LK)) :: isSorted
5215 : integer(TKR) :: rank(len(array, IK))
5216 : end function
5217 : #endif
5218 :
5219 : #if SK2_ENABLED
5220 : module function getRankModifiedCusCom_D0_SK2(array, isSorted) result(rank)
5221 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5222 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D0_SK2
5223 : #endif
5224 : use pm_kind, only: TKR => IK, SKC => SK2
5225 : character(*,SKC) , intent(in) :: array
5226 : procedure(logical(LK)) :: isSorted
5227 : integer(TKR) :: rank(len(array, IK))
5228 : end function
5229 : #endif
5230 :
5231 : #if SK1_ENABLED
5232 : module function getRankModifiedCusCom_D0_SK1(array, isSorted) result(rank)
5233 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5234 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D0_SK1
5235 : #endif
5236 : use pm_kind, only: TKR => IK, SKC => SK1
5237 : character(*,SKC) , intent(in) :: array
5238 : procedure(logical(LK)) :: isSorted
5239 : integer(TKR) :: rank(len(array, IK))
5240 : end function
5241 : #endif
5242 :
5243 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5244 :
5245 : #if SK5_ENABLED
5246 : module function getRankModifiedCusCom_D1_SK5(array, isSorted) result(rank)
5247 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5248 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_SK5
5249 : #endif
5250 : use pm_kind, only: TKR => IK, SKC => SK5
5251 : character(*,SKC) , intent(in) , contiguous :: array(:)
5252 : procedure(logical(LK)) :: isSorted
5253 : integer(TKR) :: rank(size(array, kind = IK))
5254 : end function
5255 : #endif
5256 :
5257 : #if SK4_ENABLED
5258 : module function getRankModifiedCusCom_D1_SK4(array, isSorted) result(rank)
5259 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5260 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_SK4
5261 : #endif
5262 : use pm_kind, only: TKR => IK, SKC => SK4
5263 : character(*,SKC) , intent(in) , contiguous :: array(:)
5264 : procedure(logical(LK)) :: isSorted
5265 : integer(TKR) :: rank(size(array, kind = IK))
5266 : end function
5267 : #endif
5268 :
5269 : #if SK3_ENABLED
5270 : module function getRankModifiedCusCom_D1_SK3(array, isSorted) result(rank)
5271 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5272 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_SK3
5273 : #endif
5274 : use pm_kind, only: TKR => IK, SKC => SK3
5275 : character(*,SKC) , intent(in) , contiguous :: array(:)
5276 : procedure(logical(LK)) :: isSorted
5277 : integer(TKR) :: rank(size(array, kind = IK))
5278 : end function
5279 : #endif
5280 :
5281 : #if SK2_ENABLED
5282 : module function getRankModifiedCusCom_D1_SK2(array, isSorted) result(rank)
5283 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5284 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_SK2
5285 : #endif
5286 : use pm_kind, only: TKR => IK, SKC => SK2
5287 : character(*,SKC) , intent(in) , contiguous :: array(:)
5288 : procedure(logical(LK)) :: isSorted
5289 : integer(TKR) :: rank(size(array, kind = IK))
5290 : end function
5291 : #endif
5292 :
5293 : #if SK1_ENABLED
5294 : module function getRankModifiedCusCom_D1_SK1(array, isSorted) result(rank)
5295 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5296 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_SK1
5297 : #endif
5298 : use pm_kind, only: TKR => IK, SKC => SK1
5299 : character(*,SKC) , intent(in) , contiguous :: array(:)
5300 : procedure(logical(LK)) :: isSorted
5301 : integer(TKR) :: rank(size(array, kind = IK))
5302 : end function
5303 : #endif
5304 :
5305 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5306 :
5307 : #if IK5_ENABLED
5308 : module function getRankModifiedCusCom_D1_IK5(array, isSorted) result(rank)
5309 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5310 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_IK5
5311 : #endif
5312 : use pm_kind, only: TKR => IK, IKC => IK5
5313 : integer(IKC) , intent(in) , contiguous :: array(:)
5314 : procedure(logical(LK)) :: isSorted
5315 : integer(TKR) :: rank(size(array, kind = IK))
5316 : end function
5317 : #endif
5318 :
5319 : #if IK4_ENABLED
5320 : module function getRankModifiedCusCom_D1_IK4(array, isSorted) result(rank)
5321 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5322 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_IK4
5323 : #endif
5324 : use pm_kind, only: TKR => IK, IKC => IK4
5325 : integer(IKC) , intent(in) , contiguous :: array(:)
5326 : procedure(logical(LK)) :: isSorted
5327 : integer(TKR) :: rank(size(array, kind = IK))
5328 : end function
5329 : #endif
5330 :
5331 : #if IK3_ENABLED
5332 : module function getRankModifiedCusCom_D1_IK3(array, isSorted) result(rank)
5333 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5334 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_IK3
5335 : #endif
5336 : use pm_kind, only: TKR => IK, IKC => IK3
5337 : integer(IKC) , intent(in) , contiguous :: array(:)
5338 : procedure(logical(LK)) :: isSorted
5339 : integer(TKR) :: rank(size(array, kind = IK))
5340 : end function
5341 : #endif
5342 :
5343 : #if IK2_ENABLED
5344 : module function getRankModifiedCusCom_D1_IK2(array, isSorted) result(rank)
5345 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5346 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_IK2
5347 : #endif
5348 : use pm_kind, only: TKR => IK, IKC => IK2
5349 : integer(IKC) , intent(in) , contiguous :: array(:)
5350 : procedure(logical(LK)) :: isSorted
5351 : integer(TKR) :: rank(size(array, kind = IK))
5352 : end function
5353 : #endif
5354 :
5355 : #if IK1_ENABLED
5356 : module function getRankModifiedCusCom_D1_IK1(array, isSorted) result(rank)
5357 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5358 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_IK1
5359 : #endif
5360 : use pm_kind, only: TKR => IK, IKC => IK1
5361 : integer(IKC) , intent(in) , contiguous :: array(:)
5362 : procedure(logical(LK)) :: isSorted
5363 : integer(TKR) :: rank(size(array, kind = IK))
5364 : end function
5365 : #endif
5366 :
5367 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5368 :
5369 : #if LK5_ENABLED
5370 : module function getRankModifiedCusCom_D1_LK5(array, isSorted) result(rank)
5371 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5372 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_LK5
5373 : #endif
5374 : use pm_kind, only: TKR => IK, LKC => LK5
5375 : logical(LKC) , intent(in) , contiguous :: array(:)
5376 : procedure(logical(LK)) :: isSorted
5377 : integer(TKR) :: rank(size(array, kind = IK))
5378 : end function
5379 : #endif
5380 :
5381 : #if LK4_ENABLED
5382 : module function getRankModifiedCusCom_D1_LK4(array, isSorted) result(rank)
5383 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5384 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_LK4
5385 : #endif
5386 : use pm_kind, only: TKR => IK, LKC => LK4
5387 : logical(LKC) , intent(in) , contiguous :: array(:)
5388 : procedure(logical(LK)) :: isSorted
5389 : integer(TKR) :: rank(size(array, kind = IK))
5390 : end function
5391 : #endif
5392 :
5393 : #if LK3_ENABLED
5394 : module function getRankModifiedCusCom_D1_LK3(array, isSorted) result(rank)
5395 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5396 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_LK3
5397 : #endif
5398 : use pm_kind, only: TKR => IK, LKC => LK3
5399 : logical(LKC) , intent(in) , contiguous :: array(:)
5400 : procedure(logical(LK)) :: isSorted
5401 : integer(TKR) :: rank(size(array, kind = IK))
5402 : end function
5403 : #endif
5404 :
5405 : #if LK2_ENABLED
5406 : module function getRankModifiedCusCom_D1_LK2(array, isSorted) result(rank)
5407 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5408 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_LK2
5409 : #endif
5410 : use pm_kind, only: TKR => IK, LKC => LK2
5411 : logical(LKC) , intent(in) , contiguous :: array(:)
5412 : procedure(logical(LK)) :: isSorted
5413 : integer(TKR) :: rank(size(array, kind = IK))
5414 : end function
5415 : #endif
5416 :
5417 : #if LK1_ENABLED
5418 : module function getRankModifiedCusCom_D1_LK1(array, isSorted) result(rank)
5419 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5420 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_LK1
5421 : #endif
5422 : use pm_kind, only: TKR => IK, LKC => LK1
5423 : logical(LKC) , intent(in) , contiguous :: array(:)
5424 : procedure(logical(LK)) :: isSorted
5425 : integer(TKR) :: rank(size(array, kind = IK))
5426 : end function
5427 : #endif
5428 :
5429 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5430 :
5431 : #if CK5_ENABLED
5432 : module function getRankModifiedCusCom_D1_CK5(array, isSorted) result(rank)
5433 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5434 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_CK5
5435 : #endif
5436 : use pm_kind, only: TKR => IK, CKC => CK5
5437 : complex(CKC) , intent(in) , contiguous :: array(:)
5438 : procedure(logical(LK)) :: isSorted
5439 : integer(TKR) :: rank(size(array, kind = IK))
5440 : end function
5441 : #endif
5442 :
5443 : #if CK4_ENABLED
5444 : module function getRankModifiedCusCom_D1_CK4(array, isSorted) result(rank)
5445 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5446 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_CK4
5447 : #endif
5448 : use pm_kind, only: TKR => IK, CKC => CK4
5449 : complex(CKC) , intent(in) , contiguous :: array(:)
5450 : procedure(logical(LK)) :: isSorted
5451 : integer(TKR) :: rank(size(array, kind = IK))
5452 : end function
5453 : #endif
5454 :
5455 : #if CK3_ENABLED
5456 : module function getRankModifiedCusCom_D1_CK3(array, isSorted) result(rank)
5457 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5458 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_CK3
5459 : #endif
5460 : use pm_kind, only: TKR => IK, CKC => CK3
5461 : complex(CKC) , intent(in) , contiguous :: array(:)
5462 : procedure(logical(LK)) :: isSorted
5463 : integer(TKR) :: rank(size(array, kind = IK))
5464 : end function
5465 : #endif
5466 :
5467 : #if CK2_ENABLED
5468 : module function getRankModifiedCusCom_D1_CK2(array, isSorted) result(rank)
5469 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5470 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_CK2
5471 : #endif
5472 : use pm_kind, only: TKR => IK, CKC => CK2
5473 : complex(CKC) , intent(in) , contiguous :: array(:)
5474 : procedure(logical(LK)) :: isSorted
5475 : integer(TKR) :: rank(size(array, kind = IK))
5476 : end function
5477 : #endif
5478 :
5479 : #if CK1_ENABLED
5480 : module function getRankModifiedCusCom_D1_CK1(array, isSorted) result(rank)
5481 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5482 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_CK1
5483 : #endif
5484 : use pm_kind, only: TKR => IK, CKC => CK1
5485 : complex(CKC) , intent(in) , contiguous :: array(:)
5486 : procedure(logical(LK)) :: isSorted
5487 : integer(TKR) :: rank(size(array, kind = IK))
5488 : end function
5489 : #endif
5490 :
5491 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5492 :
5493 : #if RK5_ENABLED
5494 : module function getRankModifiedCusCom_D1_RK5(array, isSorted) result(rank)
5495 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5496 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_RK5
5497 : #endif
5498 : use pm_kind, only: TKR => IK, RKC => RK5
5499 : real(RKC) , intent(in) , contiguous :: array(:)
5500 : procedure(logical(LK)) :: isSorted
5501 : integer(TKR) :: rank(size(array, kind = IK))
5502 : end function
5503 : #endif
5504 :
5505 : #if RK4_ENABLED
5506 : module function getRankModifiedCusCom_D1_RK4(array, isSorted) result(rank)
5507 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5508 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_RK4
5509 : #endif
5510 : use pm_kind, only: TKR => IK, RKC => RK4
5511 : real(RKC) , intent(in) , contiguous :: array(:)
5512 : procedure(logical(LK)) :: isSorted
5513 : integer(TKR) :: rank(size(array, kind = IK))
5514 : end function
5515 : #endif
5516 :
5517 : #if RK3_ENABLED
5518 : module function getRankModifiedCusCom_D1_RK3(array, isSorted) result(rank)
5519 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5520 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_RK3
5521 : #endif
5522 : use pm_kind, only: TKR => IK, RKC => RK3
5523 : real(RKC) , intent(in) , contiguous :: array(:)
5524 : procedure(logical(LK)) :: isSorted
5525 : integer(TKR) :: rank(size(array, kind = IK))
5526 : end function
5527 : #endif
5528 :
5529 : #if RK2_ENABLED
5530 : module function getRankModifiedCusCom_D1_RK2(array, isSorted) result(rank)
5531 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5532 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_RK2
5533 : #endif
5534 : use pm_kind, only: TKR => IK, RKC => RK2
5535 : real(RKC) , intent(in) , contiguous :: array(:)
5536 : procedure(logical(LK)) :: isSorted
5537 : integer(TKR) :: rank(size(array, kind = IK))
5538 : end function
5539 : #endif
5540 :
5541 : #if RK1_ENABLED
5542 : module function getRankModifiedCusCom_D1_RK1(array, isSorted) result(rank)
5543 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5544 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_RK1
5545 : #endif
5546 : use pm_kind, only: TKR => IK, RKC => RK1
5547 : real(RKC) , intent(in) , contiguous :: array(:)
5548 : procedure(logical(LK)) :: isSorted
5549 : integer(TKR) :: rank(size(array, kind = IK))
5550 : end function
5551 : #endif
5552 :
5553 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5554 :
5555 : #if SK5_ENABLED
5556 : module function getRankModifiedCusCom_D1_PSSK5(array, isSorted) result(rank)
5557 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5558 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_PSSK5
5559 : #endif
5560 : use pm_kind, only: TKR => IK, SKC => SK5
5561 : use pm_container, only: css_pdt
5562 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5563 : procedure(logical(LK)) :: isSorted
5564 : integer(TKR) :: rank(size(array, kind = IK))
5565 : end function
5566 : #endif
5567 :
5568 : #if SK4_ENABLED
5569 : module function getRankModifiedCusCom_D1_PSSK4(array, isSorted) result(rank)
5570 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5571 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_PSSK4
5572 : #endif
5573 : use pm_kind, only: TKR => IK, SKC => SK4
5574 : use pm_container, only: css_pdt
5575 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5576 : procedure(logical(LK)) :: isSorted
5577 : integer(TKR) :: rank(size(array, kind = IK))
5578 : end function
5579 : #endif
5580 :
5581 : #if SK3_ENABLED
5582 : module function getRankModifiedCusCom_D1_PSSK3(array, isSorted) result(rank)
5583 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5584 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_PSSK3
5585 : #endif
5586 : use pm_kind, only: TKR => IK, SKC => SK3
5587 : use pm_container, only: css_pdt
5588 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5589 : procedure(logical(LK)) :: isSorted
5590 : integer(TKR) :: rank(size(array, kind = IK))
5591 : end function
5592 : #endif
5593 :
5594 : #if SK2_ENABLED
5595 : module function getRankModifiedCusCom_D1_PSSK2(array, isSorted) result(rank)
5596 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5597 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_PSSK2
5598 : #endif
5599 : use pm_kind, only: TKR => IK, SKC => SK2
5600 : use pm_container, only: css_pdt
5601 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5602 : procedure(logical(LK)) :: isSorted
5603 : integer(TKR) :: rank(size(array, kind = IK))
5604 : end function
5605 : #endif
5606 :
5607 : #if SK1_ENABLED
5608 : module function getRankModifiedCusCom_D1_PSSK1(array, isSorted) result(rank)
5609 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5610 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_PSSK1
5611 : #endif
5612 : use pm_kind, only: TKR => IK, SKC => SK1
5613 : use pm_container, only: css_pdt
5614 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
5615 : integer(TKR) :: rank(size(array, kind = IK))
5616 : procedure(logical(LK)) :: isSorted
5617 : end function
5618 : #endif
5619 :
5620 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5621 :
5622 : module function getRankModifiedCusCom_D1_BSSK(array, isSorted) result(rank)
5623 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5624 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankModifiedCusCom_D1_BSSK
5625 : #endif
5626 : use pm_kind, only: TKR => IK, SKC => SK
5627 : use pm_container, only: css_type
5628 : type(css_type) , intent(in) , contiguous :: array(:)
5629 : procedure(logical(LK)) :: isSorted
5630 : integer(TKR) :: rank(size(array, kind = IK))
5631 : end function
5632 :
5633 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5634 :
5635 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5636 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5637 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5638 :
5639 : end interface
5640 :
5641 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5642 :
5643 : !> \brief
5644 : !> Return the **Modified rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
5645 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
5646 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
5647 : !>
5648 : !> \details
5649 : !> This kind of ranking of values is widely known as <b>Modified Competition (`1334`) ranking</b>.<br>
5650 : !> Sometimes, competition ranking is done by leaving the gaps in the ranking numbers before the sets of equal-ranking items
5651 : !> (rather than after them as in Standard Competition ranking).<br>
5652 : !> The number of ranking numbers that are left out in this gap remains one less than the number of items that compared equal.<br>
5653 : !> Equivalently, the ranking number of each item is equal to the number of items ranked equal to it or above it.<br>
5654 : !> This ranking ensures that a competitor only comes second if they score
5655 : !> higher than all but one of their opponents, third if they score higher than all but two of their opponents, etc.<br>
5656 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked head of *D*, then *A* gets ranking
5657 : !> number `1` (*first*), *B* gets ranking number `3` (*joint third*), *C* also gets ranking number `3` (*joint third*)
5658 : !> and *D* gets ranking number `4` (*fourth*). In this case, nobody would get ranking number `2` (*second*) (left as a gap).<br>
5659 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Modified Competition ranking** `1334`.<br>
5660 : !>
5661 : !> \param[out] rank : The output `contiguous` array of rank `1` of type `integer` of default kind \IK
5662 : !> containing the ranks of the corresponding elements of `array`.<br>
5663 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
5664 : !> **Read `rank(i)` as the Modified rank of the `i`th element of `array`.**
5665 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
5666 : !> <ol>
5667 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
5668 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
5669 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
5670 : !> <li> type `integer` of kind \IKALL or,<br>
5671 : !> <li> type `logical` of kind \LKALL or,<br>
5672 : !> <li> type `complex` of kind \CKALL or,<br>
5673 : !> <li> type `real` of kind \RKALL,<br>
5674 : !> </ol>
5675 : !> or,
5676 : !> <ol>
5677 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
5678 : !> </ol>
5679 : !> whose elements rankings will be computed and returned.
5680 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type
5681 : !> and kind as the input `array`.<br>
5682 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
5683 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
5684 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
5685 : !> If `array` is a Fortran string (i.e., a scalar `character`),
5686 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
5687 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
5688 : !> \code{.F90}
5689 : !> function isSorted(a,b) result (sorted)
5690 : !> use pm_kind, only: SK, IK, LK, CK, RK
5691 : !> TYPE(KIND) , intent(in) :: a, b
5692 : !> logical(LK) :: sorted
5693 : !> end function
5694 : !> \endcode
5695 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
5696 : !> \code{.F90}
5697 : !> use pm_container, only: StrCon
5698 : !> use pm_kind, only: SK, IK, LK, CK, RK
5699 : !> character(*, SK), intent(in) :: a, b
5700 : !> integer(IK) , intent(in) :: a, b
5701 : !> logical(LK) , intent(in) :: a, b
5702 : !> complex(CK) , intent(in) :: a, b
5703 : !> real(RK) , intent(in) :: a, b
5704 : !> type(StrCon) , intent(in) :: a, b
5705 : !> \endcode
5706 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
5707 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
5708 : !> \code{.F90}
5709 : !> function isSorted(a,b) result (sorted)
5710 : !> character(1,SKC), intent(in) :: a, b
5711 : !> logical(LK) :: sorted
5712 : !> end function
5713 : !> \endcode
5714 : !> where `SKC` represents the kind of the input string argument `array`.<br>
5715 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
5716 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
5717 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
5718 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
5719 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
5720 : !>
5721 : !> \interface{setRankModified}
5722 : !> \code{.F90}
5723 : !>
5724 : !> use pm_arrayRank, only: setRankModified
5725 : !>
5726 : !> call setRankModified(rank, array)
5727 : !> call setRankModified(rank, array, isSorted)
5728 : !>
5729 : !> \endcode
5730 : !>
5731 : !> \warning
5732 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
5733 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
5734 : !> identify ties within the Modified ranking of the input `array`.
5735 : !>
5736 : !> \warnpure
5737 : !>
5738 : !> \warning
5739 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
5740 : !>
5741 : !> \see
5742 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
5743 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
5744 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
5745 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
5746 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
5747 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
5748 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
5749 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
5750 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
5751 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
5752 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
5753 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
5754 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
5755 : !>
5756 : !> \example{setRankModified}
5757 : !> \include{lineno} example/pm_arrayRank/setRankModified/main.F90
5758 : !> \compilef{setRankModified}
5759 : !> \output{setRankModified}
5760 : !> \include{lineno} example/pm_arrayRank/setRankModified/main.out.F90
5761 : !>
5762 : !> \test
5763 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
5764 : !>
5765 : !> \bug
5766 : !> \status \unresolved
5767 : !> \source \ifort{2021.5}
5768 : !> \desc
5769 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
5770 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
5771 : !> \remedy
5772 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
5773 : !>
5774 : !> \todo
5775 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
5776 : !>
5777 : !> \todo
5778 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
5779 : !>
5780 : !> \finmain{setRankModified}
5781 : !>
5782 : !> \author
5783 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
5784 : interface setRankModified
5785 :
5786 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5787 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5788 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5789 :
5790 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5791 :
5792 : #if SK5_ENABLED
5793 : PURE module subroutine setRankModifiedDefCom_D0_SK5(rank, array)
5794 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5795 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D0_SK5
5796 : #endif
5797 : use pm_kind, only: TKR => IK, SKC => SK5
5798 : character(*,SKC) , intent(in) :: array
5799 : integer(TKR) , intent(out) , contiguous :: rank(:)
5800 : end subroutine
5801 : #endif
5802 :
5803 : #if SK4_ENABLED
5804 : PURE module subroutine setRankModifiedDefCom_D0_SK4(rank, array)
5805 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5806 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D0_SK4
5807 : #endif
5808 : use pm_kind, only: TKR => IK, SKC => SK4
5809 : character(*,SKC) , intent(in) :: array
5810 : integer(TKR) , intent(out) , contiguous :: rank(:)
5811 : end subroutine
5812 : #endif
5813 :
5814 : #if SK3_ENABLED
5815 : PURE module subroutine setRankModifiedDefCom_D0_SK3(rank, array)
5816 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5817 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D0_SK3
5818 : #endif
5819 : use pm_kind, only: TKR => IK, SKC => SK3
5820 : character(*,SKC) , intent(in) :: array
5821 : integer(TKR) , intent(out) , contiguous :: rank(:)
5822 : end subroutine
5823 : #endif
5824 :
5825 : #if SK2_ENABLED
5826 : PURE module subroutine setRankModifiedDefCom_D0_SK2(rank, array)
5827 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5828 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D0_SK2
5829 : #endif
5830 : use pm_kind, only: TKR => IK, SKC => SK2
5831 : character(*,SKC) , intent(in) :: array
5832 : integer(TKR) , intent(out) , contiguous :: rank(:)
5833 : end subroutine
5834 : #endif
5835 :
5836 : #if SK1_ENABLED
5837 : PURE module subroutine setRankModifiedDefCom_D0_SK1(rank, array)
5838 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5839 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D0_SK1
5840 : #endif
5841 : use pm_kind, only: TKR => IK, SKC => SK1
5842 : character(*,SKC) , intent(in) :: array
5843 : integer(TKR) , intent(out) , contiguous :: rank(:)
5844 : end subroutine
5845 : #endif
5846 :
5847 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5848 :
5849 : #if SK5_ENABLED
5850 : PURE module subroutine setRankModifiedDefCom_D1_SK5(rank, array)
5851 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5852 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_SK5
5853 : #endif
5854 : use pm_kind, only: TKR => IK, SKC => SK5
5855 : character(*,SKC) , intent(in) , contiguous :: array(:)
5856 : integer(TKR) , intent(out) , contiguous :: rank(:)
5857 : end subroutine
5858 : #endif
5859 :
5860 : #if SK4_ENABLED
5861 : PURE module subroutine setRankModifiedDefCom_D1_SK4(rank, array)
5862 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5863 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_SK4
5864 : #endif
5865 : use pm_kind, only: TKR => IK, SKC => SK4
5866 : character(*,SKC) , intent(in) , contiguous :: array(:)
5867 : integer(TKR) , intent(out) , contiguous :: rank(:)
5868 : end subroutine
5869 : #endif
5870 :
5871 : #if SK3_ENABLED
5872 : PURE module subroutine setRankModifiedDefCom_D1_SK3(rank, array)
5873 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5874 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_SK3
5875 : #endif
5876 : use pm_kind, only: TKR => IK, SKC => SK3
5877 : character(*,SKC) , intent(in) , contiguous :: array(:)
5878 : integer(TKR) , intent(out) , contiguous :: rank(:)
5879 : end subroutine
5880 : #endif
5881 :
5882 : #if SK2_ENABLED
5883 : PURE module subroutine setRankModifiedDefCom_D1_SK2(rank, array)
5884 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5885 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_SK2
5886 : #endif
5887 : use pm_kind, only: TKR => IK, SKC => SK2
5888 : character(*,SKC) , intent(in) , contiguous :: array(:)
5889 : integer(TKR) , intent(out) , contiguous :: rank(:)
5890 : end subroutine
5891 : #endif
5892 :
5893 : #if SK1_ENABLED
5894 : PURE module subroutine setRankModifiedDefCom_D1_SK1(rank, array)
5895 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5896 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_SK1
5897 : #endif
5898 : use pm_kind, only: TKR => IK, SKC => SK1
5899 : character(*,SKC) , intent(in) , contiguous :: array(:)
5900 : integer(TKR) , intent(out) , contiguous :: rank(:)
5901 : end subroutine
5902 : #endif
5903 :
5904 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5905 :
5906 : #if IK5_ENABLED
5907 : PURE module subroutine setRankModifiedDefCom_D1_IK5(rank, array)
5908 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5909 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_IK5
5910 : #endif
5911 : use pm_kind, only: TKR => IK, IKC => IK5
5912 : integer(IKC) , intent(in) , contiguous :: array(:)
5913 : integer(TKR) , intent(out) , contiguous :: rank(:)
5914 : end subroutine
5915 : #endif
5916 :
5917 : #if IK4_ENABLED
5918 : PURE module subroutine setRankModifiedDefCom_D1_IK4(rank, array)
5919 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5920 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_IK4
5921 : #endif
5922 : use pm_kind, only: TKR => IK, IKC => IK4
5923 : integer(IKC) , intent(in) , contiguous :: array(:)
5924 : integer(TKR) , intent(out) , contiguous :: rank(:)
5925 : end subroutine
5926 : #endif
5927 :
5928 : #if IK3_ENABLED
5929 : PURE module subroutine setRankModifiedDefCom_D1_IK3(rank, array)
5930 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5931 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_IK3
5932 : #endif
5933 : use pm_kind, only: TKR => IK, IKC => IK3
5934 : integer(IKC) , intent(in) , contiguous :: array(:)
5935 : integer(TKR) , intent(out) , contiguous :: rank(:)
5936 : end subroutine
5937 : #endif
5938 :
5939 : #if IK2_ENABLED
5940 : PURE module subroutine setRankModifiedDefCom_D1_IK2(rank, array)
5941 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5942 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_IK2
5943 : #endif
5944 : use pm_kind, only: TKR => IK, IKC => IK2
5945 : integer(IKC) , intent(in) , contiguous :: array(:)
5946 : integer(TKR) , intent(out) , contiguous :: rank(:)
5947 : end subroutine
5948 : #endif
5949 :
5950 : #if IK1_ENABLED
5951 : PURE module subroutine setRankModifiedDefCom_D1_IK1(rank, array)
5952 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5953 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_IK1
5954 : #endif
5955 : use pm_kind, only: TKR => IK, IKC => IK1
5956 : integer(IKC) , intent(in) , contiguous :: array(:)
5957 : integer(TKR) , intent(out) , contiguous :: rank(:)
5958 : end subroutine
5959 : #endif
5960 :
5961 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
5962 :
5963 : #if LK5_ENABLED
5964 : PURE module subroutine setRankModifiedDefCom_D1_LK5(rank, array)
5965 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5966 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_LK5
5967 : #endif
5968 : use pm_kind, only: TKR => IK, LKC => LK5
5969 : logical(LKC) , intent(in) , contiguous :: array(:)
5970 : integer(TKR) , intent(out) , contiguous :: rank(:)
5971 : end subroutine
5972 : #endif
5973 :
5974 : #if LK4_ENABLED
5975 : PURE module subroutine setRankModifiedDefCom_D1_LK4(rank, array)
5976 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5977 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_LK4
5978 : #endif
5979 : use pm_kind, only: TKR => IK, LKC => LK4
5980 : logical(LKC) , intent(in) , contiguous :: array(:)
5981 : integer(TKR) , intent(out) , contiguous :: rank(:)
5982 : end subroutine
5983 : #endif
5984 :
5985 : #if LK3_ENABLED
5986 : PURE module subroutine setRankModifiedDefCom_D1_LK3(rank, array)
5987 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5988 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_LK3
5989 : #endif
5990 : use pm_kind, only: TKR => IK, LKC => LK3
5991 : logical(LKC) , intent(in) , contiguous :: array(:)
5992 : integer(TKR) , intent(out) , contiguous :: rank(:)
5993 : end subroutine
5994 : #endif
5995 :
5996 : #if LK2_ENABLED
5997 : PURE module subroutine setRankModifiedDefCom_D1_LK2(rank, array)
5998 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
5999 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_LK2
6000 : #endif
6001 : use pm_kind, only: TKR => IK, LKC => LK2
6002 : logical(LKC) , intent(in) , contiguous :: array(:)
6003 : integer(TKR) , intent(out) , contiguous :: rank(:)
6004 : end subroutine
6005 : #endif
6006 :
6007 : #if LK1_ENABLED
6008 : PURE module subroutine setRankModifiedDefCom_D1_LK1(rank, array)
6009 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6010 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_LK1
6011 : #endif
6012 : use pm_kind, only: TKR => IK, LKC => LK1
6013 : logical(LKC) , intent(in) , contiguous :: array(:)
6014 : integer(TKR) , intent(out) , contiguous :: rank(:)
6015 : end subroutine
6016 : #endif
6017 :
6018 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6019 :
6020 : #if CK5_ENABLED
6021 : PURE module subroutine setRankModifiedDefCom_D1_CK5(rank, array)
6022 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6023 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_CK5
6024 : #endif
6025 : use pm_kind, only: TKR => IK, CKC => CK5
6026 : complex(CKC) , intent(in) , contiguous :: array(:)
6027 : integer(TKR) , intent(out) , contiguous :: rank(:)
6028 : end subroutine
6029 : #endif
6030 :
6031 : #if CK4_ENABLED
6032 : PURE module subroutine setRankModifiedDefCom_D1_CK4(rank, array)
6033 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6034 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_CK4
6035 : #endif
6036 : use pm_kind, only: TKR => IK, CKC => CK4
6037 : complex(CKC) , intent(in) , contiguous :: array(:)
6038 : integer(TKR) , intent(out) , contiguous :: rank(:)
6039 : end subroutine
6040 : #endif
6041 :
6042 : #if CK3_ENABLED
6043 : PURE module subroutine setRankModifiedDefCom_D1_CK3(rank, array)
6044 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6045 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_CK3
6046 : #endif
6047 : use pm_kind, only: TKR => IK, CKC => CK3
6048 : complex(CKC) , intent(in) , contiguous :: array(:)
6049 : integer(TKR) , intent(out) , contiguous :: rank(:)
6050 : end subroutine
6051 : #endif
6052 :
6053 : #if CK2_ENABLED
6054 : PURE module subroutine setRankModifiedDefCom_D1_CK2(rank, array)
6055 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6056 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_CK2
6057 : #endif
6058 : use pm_kind, only: TKR => IK, CKC => CK2
6059 : complex(CKC) , intent(in) , contiguous :: array(:)
6060 : integer(TKR) , intent(out) , contiguous :: rank(:)
6061 : end subroutine
6062 : #endif
6063 :
6064 : #if CK1_ENABLED
6065 : PURE module subroutine setRankModifiedDefCom_D1_CK1(rank, array)
6066 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6067 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_CK1
6068 : #endif
6069 : use pm_kind, only: TKR => IK, CKC => CK1
6070 : complex(CKC) , intent(in) , contiguous :: array(:)
6071 : integer(TKR) , intent(out) , contiguous :: rank(:)
6072 : end subroutine
6073 : #endif
6074 :
6075 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6076 :
6077 : #if RK5_ENABLED
6078 : PURE module subroutine setRankModifiedDefCom_D1_RK5(rank, array)
6079 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6080 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_RK5
6081 : #endif
6082 : use pm_kind, only: TKR => IK, RKC => RK5
6083 : real(RKC) , intent(in) , contiguous :: array(:)
6084 : integer(TKR) , intent(out) , contiguous :: rank(:)
6085 : end subroutine
6086 : #endif
6087 :
6088 : #if RK4_ENABLED
6089 : PURE module subroutine setRankModifiedDefCom_D1_RK4(rank, array)
6090 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6091 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_RK4
6092 : #endif
6093 : use pm_kind, only: TKR => IK, RKC => RK4
6094 : real(RKC) , intent(in) , contiguous :: array(:)
6095 : integer(TKR) , intent(out) , contiguous :: rank(:)
6096 : end subroutine
6097 : #endif
6098 :
6099 : #if RK3_ENABLED
6100 : PURE module subroutine setRankModifiedDefCom_D1_RK3(rank, array)
6101 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6102 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_RK3
6103 : #endif
6104 : use pm_kind, only: TKR => IK, RKC => RK3
6105 : real(RKC) , intent(in) , contiguous :: array(:)
6106 : integer(TKR) , intent(out) , contiguous :: rank(:)
6107 : end subroutine
6108 : #endif
6109 :
6110 : #if RK2_ENABLED
6111 : PURE module subroutine setRankModifiedDefCom_D1_RK2(rank, array)
6112 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6113 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_RK2
6114 : #endif
6115 : use pm_kind, only: TKR => IK, RKC => RK2
6116 : real(RKC) , intent(in) , contiguous :: array(:)
6117 : integer(TKR) , intent(out) , contiguous :: rank(:)
6118 : end subroutine
6119 : #endif
6120 :
6121 : #if RK1_ENABLED
6122 : PURE module subroutine setRankModifiedDefCom_D1_RK1(rank, array)
6123 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6124 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_RK1
6125 : #endif
6126 : use pm_kind, only: TKR => IK, RKC => RK1
6127 : real(RKC) , intent(in) , contiguous :: array(:)
6128 : integer(TKR) , intent(out) , contiguous :: rank(:)
6129 : end subroutine
6130 : #endif
6131 :
6132 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6133 :
6134 : #if SK5_ENABLED
6135 : PURE module subroutine setRankModifiedDefCom_D1_PSSK5(rank, array)
6136 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6137 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_PSSK5
6138 : #endif
6139 : use pm_kind, only: TKR => IK, SKC => SK5
6140 : use pm_container, only: css_pdt
6141 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6142 : integer(TKR) , intent(out) , contiguous :: rank(:)
6143 : end subroutine
6144 : #endif
6145 :
6146 : #if SK4_ENABLED
6147 : PURE module subroutine setRankModifiedDefCom_D1_PSSK4(rank, array)
6148 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6149 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_PSSK4
6150 : #endif
6151 : use pm_kind, only: TKR => IK, SKC => SK4
6152 : use pm_container, only: css_pdt
6153 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6154 : integer(TKR) , intent(out) , contiguous :: rank(:)
6155 : end subroutine
6156 : #endif
6157 :
6158 : #if SK3_ENABLED
6159 : PURE module subroutine setRankModifiedDefCom_D1_PSSK3(rank, array)
6160 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6161 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_PSSK3
6162 : #endif
6163 : use pm_kind, only: TKR => IK, SKC => SK3
6164 : use pm_container, only: css_pdt
6165 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6166 : integer(TKR) , intent(out) , contiguous :: rank(:)
6167 : end subroutine
6168 : #endif
6169 :
6170 : #if SK2_ENABLED
6171 : PURE module subroutine setRankModifiedDefCom_D1_PSSK2(rank, array)
6172 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6173 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_PSSK2
6174 : #endif
6175 : use pm_kind, only: TKR => IK, SKC => SK2
6176 : use pm_container, only: css_pdt
6177 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6178 : integer(TKR) , intent(out) , contiguous :: rank(:)
6179 : end subroutine
6180 : #endif
6181 :
6182 : #if SK1_ENABLED
6183 : PURE module subroutine setRankModifiedDefCom_D1_PSSK1(rank, array)
6184 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6185 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_PSSK1
6186 : #endif
6187 : use pm_kind, only: TKR => IK, SKC => SK1
6188 : use pm_container, only: css_pdt
6189 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6190 : integer(TKR) , intent(out) , contiguous :: rank(:)
6191 : end subroutine
6192 : #endif
6193 :
6194 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6195 :
6196 : PURE module subroutine setRankModifiedDefCom_D1_BSSK(rank, array)
6197 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6198 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedDefCom_D1_BSSK
6199 : #endif
6200 : use pm_kind, only: TKR => IK, SKC => SK
6201 : use pm_container, only: css_type
6202 : type(css_type) , intent(in) , contiguous :: array(:)
6203 : integer(TKR) , intent(out) , contiguous :: rank(:)
6204 : end subroutine
6205 :
6206 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6207 :
6208 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6209 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6210 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6211 :
6212 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6213 :
6214 : #if SK5_ENABLED
6215 : module subroutine setRankModifiedCusCom_D0_SK5(rank, array, isSorted)
6216 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6217 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D0_SK5
6218 : #endif
6219 : use pm_kind, only: TKR => IK, SKC => SK5
6220 : character(*,SKC) , intent(in) :: array
6221 : integer(TKR) , intent(out) , contiguous :: rank(:)
6222 : procedure(logical(LK)) :: isSorted
6223 : end subroutine
6224 : #endif
6225 :
6226 : #if SK4_ENABLED
6227 : module subroutine setRankModifiedCusCom_D0_SK4(rank, array, isSorted)
6228 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6229 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D0_SK4
6230 : #endif
6231 : use pm_kind, only: TKR => IK, SKC => SK4
6232 : character(*,SKC) , intent(in) :: array
6233 : integer(TKR) , intent(out) , contiguous :: rank(:)
6234 : procedure(logical(LK)) :: isSorted
6235 : end subroutine
6236 : #endif
6237 :
6238 : #if SK3_ENABLED
6239 : module subroutine setRankModifiedCusCom_D0_SK3(rank, array, isSorted)
6240 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6241 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D0_SK3
6242 : #endif
6243 : use pm_kind, only: TKR => IK, SKC => SK3
6244 : character(*,SKC) , intent(in) :: array
6245 : integer(TKR) , intent(out) , contiguous :: rank(:)
6246 : procedure(logical(LK)) :: isSorted
6247 : end subroutine
6248 : #endif
6249 :
6250 : #if SK2_ENABLED
6251 : module subroutine setRankModifiedCusCom_D0_SK2(rank, array, isSorted)
6252 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6253 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D0_SK2
6254 : #endif
6255 : use pm_kind, only: TKR => IK, SKC => SK2
6256 : character(*,SKC) , intent(in) :: array
6257 : integer(TKR) , intent(out) , contiguous :: rank(:)
6258 : procedure(logical(LK)) :: isSorted
6259 : end subroutine
6260 : #endif
6261 :
6262 : #if SK1_ENABLED
6263 : module subroutine setRankModifiedCusCom_D0_SK1(rank, array, isSorted)
6264 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6265 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D0_SK1
6266 : #endif
6267 : use pm_kind, only: TKR => IK, SKC => SK1
6268 : character(*,SKC) , intent(in) :: array
6269 : integer(TKR) , intent(out) , contiguous :: rank(:)
6270 : procedure(logical(LK)) :: isSorted
6271 : end subroutine
6272 : #endif
6273 :
6274 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6275 :
6276 : #if SK5_ENABLED
6277 : module subroutine setRankModifiedCusCom_D1_SK5(rank, array, isSorted)
6278 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6279 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_SK5
6280 : #endif
6281 : use pm_kind, only: TKR => IK, SKC => SK5
6282 : character(*,SKC) , intent(in) , contiguous :: array(:)
6283 : integer(TKR) , intent(out) , contiguous :: rank(:)
6284 : procedure(logical(LK)) :: isSorted
6285 : end subroutine
6286 : #endif
6287 :
6288 : #if SK4_ENABLED
6289 : module subroutine setRankModifiedCusCom_D1_SK4(rank, array, isSorted)
6290 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6291 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_SK4
6292 : #endif
6293 : use pm_kind, only: TKR => IK, SKC => SK4
6294 : character(*,SKC) , intent(in) , contiguous :: array(:)
6295 : integer(TKR) , intent(out) , contiguous :: rank(:)
6296 : procedure(logical(LK)) :: isSorted
6297 : end subroutine
6298 : #endif
6299 :
6300 : #if SK3_ENABLED
6301 : module subroutine setRankModifiedCusCom_D1_SK3(rank, array, isSorted)
6302 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6303 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_SK3
6304 : #endif
6305 : use pm_kind, only: TKR => IK, SKC => SK3
6306 : character(*,SKC) , intent(in) , contiguous :: array(:)
6307 : integer(TKR) , intent(out) , contiguous :: rank(:)
6308 : procedure(logical(LK)) :: isSorted
6309 : end subroutine
6310 : #endif
6311 :
6312 : #if SK2_ENABLED
6313 : module subroutine setRankModifiedCusCom_D1_SK2(rank, array, isSorted)
6314 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6315 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_SK2
6316 : #endif
6317 : use pm_kind, only: TKR => IK, SKC => SK2
6318 : character(*,SKC) , intent(in) , contiguous :: array(:)
6319 : integer(TKR) , intent(out) , contiguous :: rank(:)
6320 : procedure(logical(LK)) :: isSorted
6321 : end subroutine
6322 : #endif
6323 :
6324 : #if SK1_ENABLED
6325 : module subroutine setRankModifiedCusCom_D1_SK1(rank, array, isSorted)
6326 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6327 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_SK1
6328 : #endif
6329 : use pm_kind, only: TKR => IK, SKC => SK1
6330 : character(*,SKC) , intent(in) , contiguous :: array(:)
6331 : integer(TKR) , intent(out) , contiguous :: rank(:)
6332 : procedure(logical(LK)) :: isSorted
6333 : end subroutine
6334 : #endif
6335 :
6336 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6337 :
6338 : #if IK5_ENABLED
6339 : module subroutine setRankModifiedCusCom_D1_IK5(rank, array, isSorted)
6340 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6341 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_IK5
6342 : #endif
6343 : use pm_kind, only: TKR => IK, IKC => IK5
6344 : integer(IKC) , intent(in) , contiguous :: array(:)
6345 : integer(TKR) , intent(out) , contiguous :: rank(:)
6346 : procedure(logical(LK)) :: isSorted
6347 : end subroutine
6348 : #endif
6349 :
6350 : #if IK4_ENABLED
6351 : module subroutine setRankModifiedCusCom_D1_IK4(rank, array, isSorted)
6352 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6353 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_IK4
6354 : #endif
6355 : use pm_kind, only: TKR => IK, IKC => IK4
6356 : integer(IKC) , intent(in) , contiguous :: array(:)
6357 : integer(TKR) , intent(out) , contiguous :: rank(:)
6358 : procedure(logical(LK)) :: isSorted
6359 : end subroutine
6360 : #endif
6361 :
6362 : #if IK3_ENABLED
6363 : module subroutine setRankModifiedCusCom_D1_IK3(rank, array, isSorted)
6364 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6365 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_IK3
6366 : #endif
6367 : use pm_kind, only: TKR => IK, IKC => IK3
6368 : integer(IKC) , intent(in) , contiguous :: array(:)
6369 : integer(TKR) , intent(out) , contiguous :: rank(:)
6370 : procedure(logical(LK)) :: isSorted
6371 : end subroutine
6372 : #endif
6373 :
6374 : #if IK2_ENABLED
6375 : module subroutine setRankModifiedCusCom_D1_IK2(rank, array, isSorted)
6376 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6377 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_IK2
6378 : #endif
6379 : use pm_kind, only: TKR => IK, IKC => IK2
6380 : integer(IKC) , intent(in) , contiguous :: array(:)
6381 : integer(TKR) , intent(out) , contiguous :: rank(:)
6382 : procedure(logical(LK)) :: isSorted
6383 : end subroutine
6384 : #endif
6385 :
6386 : #if IK1_ENABLED
6387 : module subroutine setRankModifiedCusCom_D1_IK1(rank, array, isSorted)
6388 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6389 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_IK1
6390 : #endif
6391 : use pm_kind, only: TKR => IK, IKC => IK1
6392 : integer(IKC) , intent(in) , contiguous :: array(:)
6393 : integer(TKR) , intent(out) , contiguous :: rank(:)
6394 : procedure(logical(LK)) :: isSorted
6395 : end subroutine
6396 : #endif
6397 :
6398 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6399 :
6400 : #if LK5_ENABLED
6401 : module subroutine setRankModifiedCusCom_D1_LK5(rank, array, isSorted)
6402 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6403 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_LK5
6404 : #endif
6405 : use pm_kind, only: TKR => IK, LKC => LK5
6406 : logical(LKC) , intent(in) , contiguous :: array(:)
6407 : integer(TKR) , intent(out) , contiguous :: rank(:)
6408 : procedure(logical(LK)) :: isSorted
6409 : end subroutine
6410 : #endif
6411 :
6412 : #if LK4_ENABLED
6413 : module subroutine setRankModifiedCusCom_D1_LK4(rank, array, isSorted)
6414 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6415 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_LK4
6416 : #endif
6417 : use pm_kind, only: TKR => IK, LKC => LK4
6418 : logical(LKC) , intent(in) , contiguous :: array(:)
6419 : integer(TKR) , intent(out) , contiguous :: rank(:)
6420 : procedure(logical(LK)) :: isSorted
6421 : end subroutine
6422 : #endif
6423 :
6424 : #if LK3_ENABLED
6425 : module subroutine setRankModifiedCusCom_D1_LK3(rank, array, isSorted)
6426 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6427 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_LK3
6428 : #endif
6429 : use pm_kind, only: TKR => IK, LKC => LK3
6430 : logical(LKC) , intent(in) , contiguous :: array(:)
6431 : integer(TKR) , intent(out) , contiguous :: rank(:)
6432 : procedure(logical(LK)) :: isSorted
6433 : end subroutine
6434 : #endif
6435 :
6436 : #if LK2_ENABLED
6437 : module subroutine setRankModifiedCusCom_D1_LK2(rank, array, isSorted)
6438 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6439 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_LK2
6440 : #endif
6441 : use pm_kind, only: TKR => IK, LKC => LK2
6442 : logical(LKC) , intent(in) , contiguous :: array(:)
6443 : integer(TKR) , intent(out) , contiguous :: rank(:)
6444 : procedure(logical(LK)) :: isSorted
6445 : end subroutine
6446 : #endif
6447 :
6448 : #if LK1_ENABLED
6449 : module subroutine setRankModifiedCusCom_D1_LK1(rank, array, isSorted)
6450 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6451 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_LK1
6452 : #endif
6453 : use pm_kind, only: TKR => IK, LKC => LK1
6454 : logical(LKC) , intent(in) , contiguous :: array(:)
6455 : integer(TKR) , intent(out) , contiguous :: rank(:)
6456 : procedure(logical(LK)) :: isSorted
6457 : end subroutine
6458 : #endif
6459 :
6460 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6461 :
6462 : #if CK5_ENABLED
6463 : module subroutine setRankModifiedCusCom_D1_CK5(rank, array, isSorted)
6464 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6465 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_CK5
6466 : #endif
6467 : use pm_kind, only: TKR => IK, CKC => CK5
6468 : complex(CKC) , intent(in) , contiguous :: array(:)
6469 : integer(TKR) , intent(out) , contiguous :: rank(:)
6470 : procedure(logical(LK)) :: isSorted
6471 : end subroutine
6472 : #endif
6473 :
6474 : #if CK4_ENABLED
6475 : module subroutine setRankModifiedCusCom_D1_CK4(rank, array, isSorted)
6476 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6477 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_CK4
6478 : #endif
6479 : use pm_kind, only: TKR => IK, CKC => CK4
6480 : complex(CKC) , intent(in) , contiguous :: array(:)
6481 : integer(TKR) , intent(out) , contiguous :: rank(:)
6482 : procedure(logical(LK)) :: isSorted
6483 : end subroutine
6484 : #endif
6485 :
6486 : #if CK3_ENABLED
6487 : module subroutine setRankModifiedCusCom_D1_CK3(rank, array, isSorted)
6488 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6489 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_CK3
6490 : #endif
6491 : use pm_kind, only: TKR => IK, CKC => CK3
6492 : complex(CKC) , intent(in) , contiguous :: array(:)
6493 : integer(TKR) , intent(out) , contiguous :: rank(:)
6494 : procedure(logical(LK)) :: isSorted
6495 : end subroutine
6496 : #endif
6497 :
6498 : #if CK2_ENABLED
6499 : module subroutine setRankModifiedCusCom_D1_CK2(rank, array, isSorted)
6500 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6501 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_CK2
6502 : #endif
6503 : use pm_kind, only: TKR => IK, CKC => CK2
6504 : complex(CKC) , intent(in) , contiguous :: array(:)
6505 : integer(TKR) , intent(out) , contiguous :: rank(:)
6506 : procedure(logical(LK)) :: isSorted
6507 : end subroutine
6508 : #endif
6509 :
6510 : #if CK1_ENABLED
6511 : module subroutine setRankModifiedCusCom_D1_CK1(rank, array, isSorted)
6512 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6513 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_CK1
6514 : #endif
6515 : use pm_kind, only: TKR => IK, CKC => CK1
6516 : complex(CKC) , intent(in) , contiguous :: array(:)
6517 : integer(TKR) , intent(out) , contiguous :: rank(:)
6518 : procedure(logical(LK)) :: isSorted
6519 : end subroutine
6520 : #endif
6521 :
6522 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6523 :
6524 : #if RK5_ENABLED
6525 : module subroutine setRankModifiedCusCom_D1_RK5(rank, array, isSorted)
6526 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6527 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_RK5
6528 : #endif
6529 : use pm_kind, only: TKR => IK, RKC => RK5
6530 : real(RKC) , intent(in) , contiguous :: array(:)
6531 : integer(TKR) , intent(out) , contiguous :: rank(:)
6532 : procedure(logical(LK)) :: isSorted
6533 : end subroutine
6534 : #endif
6535 :
6536 : #if RK4_ENABLED
6537 : module subroutine setRankModifiedCusCom_D1_RK4(rank, array, isSorted)
6538 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6539 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_RK4
6540 : #endif
6541 : use pm_kind, only: TKR => IK, RKC => RK4
6542 : real(RKC) , intent(in) , contiguous :: array(:)
6543 : integer(TKR) , intent(out) , contiguous :: rank(:)
6544 : procedure(logical(LK)) :: isSorted
6545 : end subroutine
6546 : #endif
6547 :
6548 : #if RK3_ENABLED
6549 : module subroutine setRankModifiedCusCom_D1_RK3(rank, array, isSorted)
6550 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6551 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_RK3
6552 : #endif
6553 : use pm_kind, only: TKR => IK, RKC => RK3
6554 : real(RKC) , intent(in) , contiguous :: array(:)
6555 : integer(TKR) , intent(out) , contiguous :: rank(:)
6556 : procedure(logical(LK)) :: isSorted
6557 : end subroutine
6558 : #endif
6559 :
6560 : #if RK2_ENABLED
6561 : module subroutine setRankModifiedCusCom_D1_RK2(rank, array, isSorted)
6562 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6563 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_RK2
6564 : #endif
6565 : use pm_kind, only: TKR => IK, RKC => RK2
6566 : real(RKC) , intent(in) , contiguous :: array(:)
6567 : integer(TKR) , intent(out) , contiguous :: rank(:)
6568 : procedure(logical(LK)) :: isSorted
6569 : end subroutine
6570 : #endif
6571 :
6572 : #if RK1_ENABLED
6573 : module subroutine setRankModifiedCusCom_D1_RK1(rank, array, isSorted)
6574 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6575 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_RK1
6576 : #endif
6577 : use pm_kind, only: TKR => IK, RKC => RK1
6578 : real(RKC) , intent(in) , contiguous :: array(:)
6579 : integer(TKR) , intent(out) , contiguous :: rank(:)
6580 : procedure(logical(LK)) :: isSorted
6581 : end subroutine
6582 : #endif
6583 :
6584 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6585 :
6586 : #if SK5_ENABLED
6587 : module subroutine setRankModifiedCusCom_D1_PSSK5(rank, array, isSorted)
6588 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6589 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_PSSK5
6590 : #endif
6591 : use pm_kind, only: TKR => IK, SKC => SK5
6592 : use pm_container, only: css_pdt
6593 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6594 : integer(TKR) , intent(out) , contiguous :: rank(:)
6595 : procedure(logical(LK)) :: isSorted
6596 : end subroutine
6597 : #endif
6598 :
6599 : #if SK4_ENABLED
6600 : module subroutine setRankModifiedCusCom_D1_PSSK4(rank, array, isSorted)
6601 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6602 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_PSSK4
6603 : #endif
6604 : use pm_kind, only: TKR => IK, SKC => SK4
6605 : use pm_container, only: css_pdt
6606 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6607 : integer(TKR) , intent(out) , contiguous :: rank(:)
6608 : procedure(logical(LK)) :: isSorted
6609 : end subroutine
6610 : #endif
6611 :
6612 : #if SK3_ENABLED
6613 : module subroutine setRankModifiedCusCom_D1_PSSK3(rank, array, isSorted)
6614 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6615 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_PSSK3
6616 : #endif
6617 : use pm_kind, only: TKR => IK, SKC => SK3
6618 : use pm_container, only: css_pdt
6619 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6620 : integer(TKR) , intent(out) , contiguous :: rank(:)
6621 : procedure(logical(LK)) :: isSorted
6622 : end subroutine
6623 : #endif
6624 :
6625 : #if SK2_ENABLED
6626 : module subroutine setRankModifiedCusCom_D1_PSSK2(rank, array, isSorted)
6627 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6628 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_PSSK2
6629 : #endif
6630 : use pm_kind, only: TKR => IK, SKC => SK2
6631 : use pm_container, only: css_pdt
6632 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6633 : integer(TKR) , intent(out) , contiguous :: rank(:)
6634 : procedure(logical(LK)) :: isSorted
6635 : end subroutine
6636 : #endif
6637 :
6638 : #if SK1_ENABLED
6639 : module subroutine setRankModifiedCusCom_D1_PSSK1(rank, array, isSorted)
6640 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6641 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_PSSK1
6642 : #endif
6643 : use pm_kind, only: TKR => IK, SKC => SK1
6644 : use pm_container, only: css_pdt
6645 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
6646 : integer(TKR) , intent(out) , contiguous :: rank(:)
6647 : procedure(logical(LK)) :: isSorted
6648 : end subroutine
6649 : #endif
6650 :
6651 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6652 :
6653 : module subroutine setRankModifiedCusCom_D1_BSSK(rank, array, isSorted)
6654 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6655 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankModifiedCusCom_D1_BSSK
6656 : #endif
6657 : use pm_kind, only: TKR => IK, SKC => SK
6658 : use pm_container, only: css_type
6659 : type(css_type) , intent(in) , contiguous :: array(:)
6660 : integer(TKR) , intent(out) , contiguous :: rank(:)
6661 : procedure(logical(LK)) :: isSorted
6662 : end subroutine
6663 :
6664 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6665 :
6666 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6667 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6668 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6669 :
6670 : end interface
6671 :
6672 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6673 :
6674 : !> \brief
6675 : !> Generate and return the **ordinal rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
6676 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
6677 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
6678 : !>
6679 : !> \details
6680 : !> This kind of ranking of values is widely known as <b>ordinal (`1234`) ranking</b>.<br>
6681 : !> In ordinal ranking, all items receive distinct ordinal numbers, including items that compare equal.<br>
6682 : !> The assignment of distinct ordinal numbers to items that compare equal can be done at random, or arbitrarily,
6683 : !> but it is generally preferable to use a system that is arbitrary but consistent,
6684 : !> as this gives stable results if the ranking is done multiple times.<br>
6685 : !> In computer data processing, ordinal ranking is also referred to as **row numbering**.
6686 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **ordinal ranking** `1234`.<br>
6687 : !>
6688 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
6689 : !> <ol>
6690 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
6691 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
6692 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
6693 : !> <li> type `integer` of kind \IKALL or,<br>
6694 : !> <li> type `logical` of kind \LKALL or,<br>
6695 : !> <li> type `complex` of kind \CKALL or,<br>
6696 : !> <li> type `real` of kind \RKALL,<br>
6697 : !> </ol>
6698 : !> or,
6699 : !> <ol>
6700 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
6701 : !> </ol>
6702 : !> whose elements rankings will be computed and returned.
6703 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type and kind as the input `array`.<br>
6704 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
6705 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
6706 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
6707 : !> If `array` is a Fortran string (i.e., a scalar `character`),
6708 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
6709 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
6710 : !> \code{.F90}
6711 : !> function isSorted(a,b) result (sorted)
6712 : !> use pm_kind, only: SK, IK, LK, CK, RK
6713 : !> TYPE(KIND) , intent(in) :: a, b
6714 : !> logical(LK) :: sorted
6715 : !> end function
6716 : !> \endcode
6717 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
6718 : !> \code{.F90}
6719 : !> use pm_container, only: StrCon
6720 : !> use pm_kind, only: SK, IK, LK, CK, RK
6721 : !> character(*, SK), intent(in) :: a, b
6722 : !> integer(IK) , intent(in) :: a, b
6723 : !> logical(LK) , intent(in) :: a, b
6724 : !> complex(CK) , intent(in) :: a, b
6725 : !> real(RK) , intent(in) :: a, b
6726 : !> type(StrCon) , intent(in) :: a, b
6727 : !> \endcode
6728 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
6729 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
6730 : !> \code{.F90}
6731 : !> function isSorted(a,b) result (sorted)
6732 : !> character(1,SKC), intent(in) :: a, b
6733 : !> logical(LK) :: sorted
6734 : !> end function
6735 : !> \endcode
6736 : !> where `SKC` represents the kind of the input string argument `array`.<br>
6737 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
6738 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
6739 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
6740 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
6741 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
6742 : !>
6743 : !> \return
6744 : !> `rank(1:size(array)` : The output `contiguous` array of rank `1` of type `integer` of default kind \IK containing the ranks of the corresponding elements of `array`.<br>
6745 : !> The size of `rank` matches that of `array` (or its length type parameter if `array` is a scalar string).<br>
6746 : !> **Read `rank(i)` as the ordinal rank of the `i`th element of `array`.**
6747 : !>
6748 : !> \interface{getRankOrdinal}
6749 : !> \code{.F90}
6750 : !>
6751 : !> use pm_arrayRank, only: getRankOrdinal
6752 : !>
6753 : !> rank(1:size(array)) = getRankOrdinal(array)
6754 : !> rank(1:size(array)) = getRankOrdinal(array, isSorted)
6755 : !>
6756 : !> \endcode
6757 : !>
6758 : !> \warning
6759 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
6760 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
6761 : !> identify ties within the Standard ranking of the input `array`.
6762 : !>
6763 : !> \warnpure
6764 : !>
6765 : !> \warning
6766 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
6767 : !>
6768 : !> \see
6769 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
6770 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
6771 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
6772 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
6773 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
6774 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
6775 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
6776 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
6777 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
6778 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
6779 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
6780 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
6781 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
6782 : !>
6783 : !> \example{getRankOrdinal}
6784 : !> \include{lineno} example/pm_arrayRank/getRankOrdinal/main.F90
6785 : !> \compilef{getRankOrdinal}
6786 : !> \output{getRankOrdinal}
6787 : !> \include{lineno} example/pm_arrayRank/getRankOrdinal/main.out.F90
6788 : !>
6789 : !> \test
6790 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
6791 : !>
6792 : !> \bug
6793 : !> \status \unresolved
6794 : !> \source \ifort{2021.5}
6795 : !> \desc
6796 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
6797 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
6798 : !> \remedy
6799 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
6800 : !>
6801 : !> \todo
6802 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
6803 : !>
6804 : !> \todo
6805 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
6806 : !>
6807 : !> \finmain{getRankOrdinal}
6808 : !>
6809 : !> \author
6810 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
6811 : interface getRankOrdinal
6812 :
6813 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6814 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6815 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6816 :
6817 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6818 :
6819 : #if SK5_ENABLED
6820 : module function getRankOrdinalDefCom_D0_SK5(array) result(rank)
6821 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6822 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D0_SK5
6823 : #endif
6824 : use pm_kind, only: TKR => IK, SKC => SK5
6825 : character(*,SKC) , intent(in) :: array
6826 : integer(TKR) :: rank(len(array, IK))
6827 : end function
6828 : #endif
6829 :
6830 : #if SK4_ENABLED
6831 : module function getRankOrdinalDefCom_D0_SK4(array) result(rank)
6832 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6833 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D0_SK4
6834 : #endif
6835 : use pm_kind, only: TKR => IK, SKC => SK4
6836 : character(*,SKC) , intent(in) :: array
6837 : integer(TKR) :: rank(len(array, IK))
6838 : end function
6839 : #endif
6840 :
6841 : #if SK3_ENABLED
6842 : module function getRankOrdinalDefCom_D0_SK3(array) result(rank)
6843 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6844 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D0_SK3
6845 : #endif
6846 : use pm_kind, only: TKR => IK, SKC => SK3
6847 : character(*,SKC) , intent(in) :: array
6848 : integer(TKR) :: rank(len(array, IK))
6849 : end function
6850 : #endif
6851 :
6852 : #if SK2_ENABLED
6853 : module function getRankOrdinalDefCom_D0_SK2(array) result(rank)
6854 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6855 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D0_SK2
6856 : #endif
6857 : use pm_kind, only: TKR => IK, SKC => SK2
6858 : character(*,SKC) , intent(in) :: array
6859 : integer(TKR) :: rank(len(array, IK))
6860 : end function
6861 : #endif
6862 :
6863 : #if SK1_ENABLED
6864 : module function getRankOrdinalDefCom_D0_SK1(array) result(rank)
6865 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6866 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D0_SK1
6867 : #endif
6868 : use pm_kind, only: TKR => IK, SKC => SK1
6869 : character(*,SKC) , intent(in) :: array
6870 : integer(TKR) :: rank(len(array, IK))
6871 : end function
6872 : #endif
6873 :
6874 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6875 :
6876 : #if SK5_ENABLED
6877 : module function getRankOrdinalDefCom_D1_SK5(array) result(rank)
6878 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6879 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_SK5
6880 : #endif
6881 : use pm_kind, only: TKR => IK, SKC => SK5
6882 : character(*,SKC) , intent(in) , contiguous :: array(:)
6883 : integer(TKR) :: rank(size(array, kind = IK))
6884 : end function
6885 : #endif
6886 :
6887 : #if SK4_ENABLED
6888 : module function getRankOrdinalDefCom_D1_SK4(array) result(rank)
6889 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6890 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_SK4
6891 : #endif
6892 : use pm_kind, only: TKR => IK, SKC => SK4
6893 : character(*,SKC) , intent(in) , contiguous :: array(:)
6894 : integer(TKR) :: rank(size(array, kind = IK))
6895 : end function
6896 : #endif
6897 :
6898 : #if SK3_ENABLED
6899 : module function getRankOrdinalDefCom_D1_SK3(array) result(rank)
6900 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6901 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_SK3
6902 : #endif
6903 : use pm_kind, only: TKR => IK, SKC => SK3
6904 : character(*,SKC) , intent(in) , contiguous :: array(:)
6905 : integer(TKR) :: rank(size(array, kind = IK))
6906 : end function
6907 : #endif
6908 :
6909 : #if SK2_ENABLED
6910 : module function getRankOrdinalDefCom_D1_SK2(array) result(rank)
6911 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6912 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_SK2
6913 : #endif
6914 : use pm_kind, only: TKR => IK, SKC => SK2
6915 : character(*,SKC) , intent(in) , contiguous :: array(:)
6916 : integer(TKR) :: rank(size(array, kind = IK))
6917 : end function
6918 : #endif
6919 :
6920 : #if SK1_ENABLED
6921 : module function getRankOrdinalDefCom_D1_SK1(array) result(rank)
6922 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6923 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_SK1
6924 : #endif
6925 : use pm_kind, only: TKR => IK, SKC => SK1
6926 : character(*,SKC) , intent(in) , contiguous :: array(:)
6927 : integer(TKR) :: rank(size(array, kind = IK))
6928 : end function
6929 : #endif
6930 :
6931 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6932 :
6933 : #if IK5_ENABLED
6934 : module function getRankOrdinalDefCom_D1_IK5(array) result(rank)
6935 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6936 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_IK5
6937 : #endif
6938 : use pm_kind, only: TKR => IK, IKC => IK5
6939 : integer(IKC) , intent(in) , contiguous :: array(:)
6940 : integer(TKR) :: rank(size(array, kind = IK))
6941 : end function
6942 : #endif
6943 :
6944 : #if IK4_ENABLED
6945 : module function getRankOrdinalDefCom_D1_IK4(array) result(rank)
6946 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6947 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_IK4
6948 : #endif
6949 : use pm_kind, only: TKR => IK, IKC => IK4
6950 : integer(IKC) , intent(in) , contiguous :: array(:)
6951 : integer(TKR) :: rank(size(array, kind = IK))
6952 : end function
6953 : #endif
6954 :
6955 : #if IK3_ENABLED
6956 : module function getRankOrdinalDefCom_D1_IK3(array) result(rank)
6957 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6958 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_IK3
6959 : #endif
6960 : use pm_kind, only: TKR => IK, IKC => IK3
6961 : integer(IKC) , intent(in) , contiguous :: array(:)
6962 : integer(TKR) :: rank(size(array, kind = IK))
6963 : end function
6964 : #endif
6965 :
6966 : #if IK2_ENABLED
6967 : module function getRankOrdinalDefCom_D1_IK2(array) result(rank)
6968 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6969 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_IK2
6970 : #endif
6971 : use pm_kind, only: TKR => IK, IKC => IK2
6972 : integer(IKC) , intent(in) , contiguous :: array(:)
6973 : integer(TKR) :: rank(size(array, kind = IK))
6974 : end function
6975 : #endif
6976 :
6977 : #if IK1_ENABLED
6978 : module function getRankOrdinalDefCom_D1_IK1(array) result(rank)
6979 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6980 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_IK1
6981 : #endif
6982 : use pm_kind, only: TKR => IK, IKC => IK1
6983 : integer(IKC) , intent(in) , contiguous :: array(:)
6984 : integer(TKR) :: rank(size(array, kind = IK))
6985 : end function
6986 : #endif
6987 :
6988 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
6989 :
6990 : #if LK5_ENABLED
6991 : module function getRankOrdinalDefCom_D1_LK5(array) result(rank)
6992 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
6993 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_LK5
6994 : #endif
6995 : use pm_kind, only: TKR => IK, LKC => LK5
6996 : logical(LKC) , intent(in) , contiguous :: array(:)
6997 : integer(TKR) :: rank(size(array, kind = IK))
6998 : end function
6999 : #endif
7000 :
7001 : #if LK4_ENABLED
7002 : module function getRankOrdinalDefCom_D1_LK4(array) result(rank)
7003 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7004 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_LK4
7005 : #endif
7006 : use pm_kind, only: TKR => IK, LKC => LK4
7007 : logical(LKC) , intent(in) , contiguous :: array(:)
7008 : integer(TKR) :: rank(size(array, kind = IK))
7009 : end function
7010 : #endif
7011 :
7012 : #if LK3_ENABLED
7013 : module function getRankOrdinalDefCom_D1_LK3(array) result(rank)
7014 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7015 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_LK3
7016 : #endif
7017 : use pm_kind, only: TKR => IK, LKC => LK3
7018 : logical(LKC) , intent(in) , contiguous :: array(:)
7019 : integer(TKR) :: rank(size(array, kind = IK))
7020 : end function
7021 : #endif
7022 :
7023 : #if LK2_ENABLED
7024 : module function getRankOrdinalDefCom_D1_LK2(array) result(rank)
7025 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7026 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_LK2
7027 : #endif
7028 : use pm_kind, only: TKR => IK, LKC => LK2
7029 : logical(LKC) , intent(in) , contiguous :: array(:)
7030 : integer(TKR) :: rank(size(array, kind = IK))
7031 : end function
7032 : #endif
7033 :
7034 : #if LK1_ENABLED
7035 : module function getRankOrdinalDefCom_D1_LK1(array) result(rank)
7036 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7037 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_LK1
7038 : #endif
7039 : use pm_kind, only: TKR => IK, LKC => LK1
7040 : logical(LKC) , intent(in) , contiguous :: array(:)
7041 : integer(TKR) :: rank(size(array, kind = IK))
7042 : end function
7043 : #endif
7044 :
7045 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7046 :
7047 : #if CK5_ENABLED
7048 : module function getRankOrdinalDefCom_D1_CK5(array) result(rank)
7049 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7050 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_CK5
7051 : #endif
7052 : use pm_kind, only: TKR => IK, CKC => CK5
7053 : complex(CKC) , intent(in) , contiguous :: array(:)
7054 : integer(TKR) :: rank(size(array, kind = IK))
7055 : end function
7056 : #endif
7057 :
7058 : #if CK4_ENABLED
7059 : module function getRankOrdinalDefCom_D1_CK4(array) result(rank)
7060 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7061 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_CK4
7062 : #endif
7063 : use pm_kind, only: TKR => IK, CKC => CK4
7064 : complex(CKC) , intent(in) , contiguous :: array(:)
7065 : integer(TKR) :: rank(size(array, kind = IK))
7066 : end function
7067 : #endif
7068 :
7069 : #if CK3_ENABLED
7070 : module function getRankOrdinalDefCom_D1_CK3(array) result(rank)
7071 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7072 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_CK3
7073 : #endif
7074 : use pm_kind, only: TKR => IK, CKC => CK3
7075 : complex(CKC) , intent(in) , contiguous :: array(:)
7076 : integer(TKR) :: rank(size(array, kind = IK))
7077 : end function
7078 : #endif
7079 :
7080 : #if CK2_ENABLED
7081 : module function getRankOrdinalDefCom_D1_CK2(array) result(rank)
7082 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7083 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_CK2
7084 : #endif
7085 : use pm_kind, only: TKR => IK, CKC => CK2
7086 : complex(CKC) , intent(in) , contiguous :: array(:)
7087 : integer(TKR) :: rank(size(array, kind = IK))
7088 : end function
7089 : #endif
7090 :
7091 : #if CK1_ENABLED
7092 : module function getRankOrdinalDefCom_D1_CK1(array) result(rank)
7093 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7094 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_CK1
7095 : #endif
7096 : use pm_kind, only: TKR => IK, CKC => CK1
7097 : complex(CKC) , intent(in) , contiguous :: array(:)
7098 : integer(TKR) :: rank(size(array, kind = IK))
7099 : end function
7100 : #endif
7101 :
7102 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7103 :
7104 : #if RK5_ENABLED
7105 : module function getRankOrdinalDefCom_D1_RK5(array) result(rank)
7106 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7107 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_RK5
7108 : #endif
7109 : use pm_kind, only: TKR => IK, RKC => RK5
7110 : real(RKC) , intent(in) , contiguous :: array(:)
7111 : integer(TKR) :: rank(size(array, kind = IK))
7112 : end function
7113 : #endif
7114 :
7115 : #if RK4_ENABLED
7116 : module function getRankOrdinalDefCom_D1_RK4(array) result(rank)
7117 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7118 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_RK4
7119 : #endif
7120 : use pm_kind, only: TKR => IK, RKC => RK4
7121 : real(RKC) , intent(in) , contiguous :: array(:)
7122 : integer(TKR) :: rank(size(array, kind = IK))
7123 : end function
7124 : #endif
7125 :
7126 : #if RK3_ENABLED
7127 : module function getRankOrdinalDefCom_D1_RK3(array) result(rank)
7128 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7129 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_RK3
7130 : #endif
7131 : use pm_kind, only: TKR => IK, RKC => RK3
7132 : real(RKC) , intent(in) , contiguous :: array(:)
7133 : integer(TKR) :: rank(size(array, kind = IK))
7134 : end function
7135 : #endif
7136 :
7137 : #if RK2_ENABLED
7138 : module function getRankOrdinalDefCom_D1_RK2(array) result(rank)
7139 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7140 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_RK2
7141 : #endif
7142 : use pm_kind, only: TKR => IK, RKC => RK2
7143 : real(RKC) , intent(in) , contiguous :: array(:)
7144 : integer(TKR) :: rank(size(array, kind = IK))
7145 : end function
7146 : #endif
7147 :
7148 : #if RK1_ENABLED
7149 : module function getRankOrdinalDefCom_D1_RK1(array) result(rank)
7150 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7151 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_RK1
7152 : #endif
7153 : use pm_kind, only: TKR => IK, RKC => RK1
7154 : real(RKC) , intent(in) , contiguous :: array(:)
7155 : integer(TKR) :: rank(size(array, kind = IK))
7156 : end function
7157 : #endif
7158 :
7159 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7160 :
7161 : #if SK5_ENABLED
7162 : module function getRankOrdinalDefCom_D1_PSSK5(array) result(rank)
7163 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7164 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_PSSK5
7165 : #endif
7166 : use pm_kind, only: TKR => IK, SKC => SK5
7167 : use pm_container, only: css_pdt
7168 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7169 : integer(TKR) :: rank(size(array, kind = IK))
7170 : end function
7171 : #endif
7172 :
7173 : #if SK4_ENABLED
7174 : module function getRankOrdinalDefCom_D1_PSSK4(array) result(rank)
7175 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7176 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_PSSK4
7177 : #endif
7178 : use pm_kind, only: TKR => IK, SKC => SK4
7179 : use pm_container, only: css_pdt
7180 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7181 : integer(TKR) :: rank(size(array, kind = IK))
7182 : end function
7183 : #endif
7184 :
7185 : #if SK3_ENABLED
7186 : module function getRankOrdinalDefCom_D1_PSSK3(array) result(rank)
7187 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7188 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_PSSK3
7189 : #endif
7190 : use pm_kind, only: TKR => IK, SKC => SK3
7191 : use pm_container, only: css_pdt
7192 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7193 : integer(TKR) :: rank(size(array, kind = IK))
7194 : end function
7195 : #endif
7196 :
7197 : #if SK2_ENABLED
7198 : module function getRankOrdinalDefCom_D1_PSSK2(array) result(rank)
7199 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7200 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_PSSK2
7201 : #endif
7202 : use pm_kind, only: TKR => IK, SKC => SK2
7203 : use pm_container, only: css_pdt
7204 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7205 : integer(TKR) :: rank(size(array, kind = IK))
7206 : end function
7207 : #endif
7208 :
7209 : #if SK1_ENABLED
7210 : module function getRankOrdinalDefCom_D1_PSSK1(array) result(rank)
7211 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7212 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_PSSK1
7213 : #endif
7214 : use pm_kind, only: TKR => IK, SKC => SK1
7215 : use pm_container, only: css_pdt
7216 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7217 : integer(TKR) :: rank(size(array, kind = IK))
7218 : end function
7219 : #endif
7220 :
7221 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7222 :
7223 : module function getRankOrdinalDefCom_D1_BSSK(array) result(rank)
7224 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7225 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalDefCom_D1_BSSK
7226 : #endif
7227 : use pm_kind, only: TKR => IK, SKC => SK
7228 : use pm_container, only: css_type
7229 : type(css_type) , intent(in) , contiguous :: array(:)
7230 : integer(TKR) :: rank(size(array, kind = IK))
7231 : end function
7232 :
7233 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7234 :
7235 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7236 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7237 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7238 :
7239 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7240 :
7241 : #if SK5_ENABLED
7242 : module function getRankOrdinalCusCom_D0_SK5(array, isSorted) result(rank)
7243 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7244 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D0_SK5
7245 : #endif
7246 : use pm_kind, only: TKR => IK, SKC => SK5
7247 : character(*,SKC) , intent(in) :: array
7248 : procedure(logical(LK)) :: isSorted
7249 : integer(TKR) :: rank(len(array, IK))
7250 : end function
7251 : #endif
7252 :
7253 : #if SK4_ENABLED
7254 : module function getRankOrdinalCusCom_D0_SK4(array, isSorted) result(rank)
7255 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7256 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D0_SK4
7257 : #endif
7258 : use pm_kind, only: TKR => IK, SKC => SK4
7259 : character(*,SKC) , intent(in) :: array
7260 : procedure(logical(LK)) :: isSorted
7261 : integer(TKR) :: rank(len(array, IK))
7262 : end function
7263 : #endif
7264 :
7265 : #if SK3_ENABLED
7266 : module function getRankOrdinalCusCom_D0_SK3(array, isSorted) result(rank)
7267 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7268 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D0_SK3
7269 : #endif
7270 : use pm_kind, only: TKR => IK, SKC => SK3
7271 : character(*,SKC) , intent(in) :: array
7272 : procedure(logical(LK)) :: isSorted
7273 : integer(TKR) :: rank(len(array, IK))
7274 : end function
7275 : #endif
7276 :
7277 : #if SK2_ENABLED
7278 : module function getRankOrdinalCusCom_D0_SK2(array, isSorted) result(rank)
7279 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7280 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D0_SK2
7281 : #endif
7282 : use pm_kind, only: TKR => IK, SKC => SK2
7283 : character(*,SKC) , intent(in) :: array
7284 : procedure(logical(LK)) :: isSorted
7285 : integer(TKR) :: rank(len(array, IK))
7286 : end function
7287 : #endif
7288 :
7289 : #if SK1_ENABLED
7290 : module function getRankOrdinalCusCom_D0_SK1(array, isSorted) result(rank)
7291 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7292 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D0_SK1
7293 : #endif
7294 : use pm_kind, only: TKR => IK, SKC => SK1
7295 : character(*,SKC) , intent(in) :: array
7296 : procedure(logical(LK)) :: isSorted
7297 : integer(TKR) :: rank(len(array, IK))
7298 : end function
7299 : #endif
7300 :
7301 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7302 :
7303 : #if SK5_ENABLED
7304 : module function getRankOrdinalCusCom_D1_SK5(array, isSorted) result(rank)
7305 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7306 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_SK5
7307 : #endif
7308 : use pm_kind, only: TKR => IK, SKC => SK5
7309 : character(*,SKC) , intent(in) , contiguous :: array(:)
7310 : procedure(logical(LK)) :: isSorted
7311 : integer(TKR) :: rank(size(array, kind = IK))
7312 : end function
7313 : #endif
7314 :
7315 : #if SK4_ENABLED
7316 : module function getRankOrdinalCusCom_D1_SK4(array, isSorted) result(rank)
7317 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7318 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_SK4
7319 : #endif
7320 : use pm_kind, only: TKR => IK, SKC => SK4
7321 : character(*,SKC) , intent(in) , contiguous :: array(:)
7322 : procedure(logical(LK)) :: isSorted
7323 : integer(TKR) :: rank(size(array, kind = IK))
7324 : end function
7325 : #endif
7326 :
7327 : #if SK3_ENABLED
7328 : module function getRankOrdinalCusCom_D1_SK3(array, isSorted) result(rank)
7329 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7330 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_SK3
7331 : #endif
7332 : use pm_kind, only: TKR => IK, SKC => SK3
7333 : character(*,SKC) , intent(in) , contiguous :: array(:)
7334 : procedure(logical(LK)) :: isSorted
7335 : integer(TKR) :: rank(size(array, kind = IK))
7336 : end function
7337 : #endif
7338 :
7339 : #if SK2_ENABLED
7340 : module function getRankOrdinalCusCom_D1_SK2(array, isSorted) result(rank)
7341 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7342 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_SK2
7343 : #endif
7344 : use pm_kind, only: TKR => IK, SKC => SK2
7345 : character(*,SKC) , intent(in) , contiguous :: array(:)
7346 : procedure(logical(LK)) :: isSorted
7347 : integer(TKR) :: rank(size(array, kind = IK))
7348 : end function
7349 : #endif
7350 :
7351 : #if SK1_ENABLED
7352 : module function getRankOrdinalCusCom_D1_SK1(array, isSorted) result(rank)
7353 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7354 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_SK1
7355 : #endif
7356 : use pm_kind, only: TKR => IK, SKC => SK1
7357 : character(*,SKC) , intent(in) , contiguous :: array(:)
7358 : procedure(logical(LK)) :: isSorted
7359 : integer(TKR) :: rank(size(array, kind = IK))
7360 : end function
7361 : #endif
7362 :
7363 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7364 :
7365 : #if IK5_ENABLED
7366 : module function getRankOrdinalCusCom_D1_IK5(array, isSorted) result(rank)
7367 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7368 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_IK5
7369 : #endif
7370 : use pm_kind, only: TKR => IK, IKC => IK5
7371 : integer(IKC) , intent(in) , contiguous :: array(:)
7372 : procedure(logical(LK)) :: isSorted
7373 : integer(TKR) :: rank(size(array, kind = IK))
7374 : end function
7375 : #endif
7376 :
7377 : #if IK4_ENABLED
7378 : module function getRankOrdinalCusCom_D1_IK4(array, isSorted) result(rank)
7379 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7380 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_IK4
7381 : #endif
7382 : use pm_kind, only: TKR => IK, IKC => IK4
7383 : integer(IKC) , intent(in) , contiguous :: array(:)
7384 : procedure(logical(LK)) :: isSorted
7385 : integer(TKR) :: rank(size(array, kind = IK))
7386 : end function
7387 : #endif
7388 :
7389 : #if IK3_ENABLED
7390 : module function getRankOrdinalCusCom_D1_IK3(array, isSorted) result(rank)
7391 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7392 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_IK3
7393 : #endif
7394 : use pm_kind, only: TKR => IK, IKC => IK3
7395 : integer(IKC) , intent(in) , contiguous :: array(:)
7396 : procedure(logical(LK)) :: isSorted
7397 : integer(TKR) :: rank(size(array, kind = IK))
7398 : end function
7399 : #endif
7400 :
7401 : #if IK2_ENABLED
7402 : module function getRankOrdinalCusCom_D1_IK2(array, isSorted) result(rank)
7403 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7404 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_IK2
7405 : #endif
7406 : use pm_kind, only: TKR => IK, IKC => IK2
7407 : integer(IKC) , intent(in) , contiguous :: array(:)
7408 : procedure(logical(LK)) :: isSorted
7409 : integer(TKR) :: rank(size(array, kind = IK))
7410 : end function
7411 : #endif
7412 :
7413 : #if IK1_ENABLED
7414 : module function getRankOrdinalCusCom_D1_IK1(array, isSorted) result(rank)
7415 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7416 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_IK1
7417 : #endif
7418 : use pm_kind, only: TKR => IK, IKC => IK1
7419 : integer(IKC) , intent(in) , contiguous :: array(:)
7420 : procedure(logical(LK)) :: isSorted
7421 : integer(TKR) :: rank(size(array, kind = IK))
7422 : end function
7423 : #endif
7424 :
7425 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7426 :
7427 : #if LK5_ENABLED
7428 : module function getRankOrdinalCusCom_D1_LK5(array, isSorted) result(rank)
7429 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7430 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_LK5
7431 : #endif
7432 : use pm_kind, only: TKR => IK, LKC => LK5
7433 : logical(LKC) , intent(in) , contiguous :: array(:)
7434 : procedure(logical(LK)) :: isSorted
7435 : integer(TKR) :: rank(size(array, kind = IK))
7436 : end function
7437 : #endif
7438 :
7439 : #if LK4_ENABLED
7440 : module function getRankOrdinalCusCom_D1_LK4(array, isSorted) result(rank)
7441 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7442 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_LK4
7443 : #endif
7444 : use pm_kind, only: TKR => IK, LKC => LK4
7445 : logical(LKC) , intent(in) , contiguous :: array(:)
7446 : procedure(logical(LK)) :: isSorted
7447 : integer(TKR) :: rank(size(array, kind = IK))
7448 : end function
7449 : #endif
7450 :
7451 : #if LK3_ENABLED
7452 : module function getRankOrdinalCusCom_D1_LK3(array, isSorted) result(rank)
7453 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7454 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_LK3
7455 : #endif
7456 : use pm_kind, only: TKR => IK, LKC => LK3
7457 : logical(LKC) , intent(in) , contiguous :: array(:)
7458 : procedure(logical(LK)) :: isSorted
7459 : integer(TKR) :: rank(size(array, kind = IK))
7460 : end function
7461 : #endif
7462 :
7463 : #if LK2_ENABLED
7464 : module function getRankOrdinalCusCom_D1_LK2(array, isSorted) result(rank)
7465 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7466 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_LK2
7467 : #endif
7468 : use pm_kind, only: TKR => IK, LKC => LK2
7469 : logical(LKC) , intent(in) , contiguous :: array(:)
7470 : procedure(logical(LK)) :: isSorted
7471 : integer(TKR) :: rank(size(array, kind = IK))
7472 : end function
7473 : #endif
7474 :
7475 : #if LK1_ENABLED
7476 : module function getRankOrdinalCusCom_D1_LK1(array, isSorted) result(rank)
7477 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7478 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_LK1
7479 : #endif
7480 : use pm_kind, only: TKR => IK, LKC => LK1
7481 : logical(LKC) , intent(in) , contiguous :: array(:)
7482 : procedure(logical(LK)) :: isSorted
7483 : integer(TKR) :: rank(size(array, kind = IK))
7484 : end function
7485 : #endif
7486 :
7487 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7488 :
7489 : #if CK5_ENABLED
7490 : module function getRankOrdinalCusCom_D1_CK5(array, isSorted) result(rank)
7491 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7492 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_CK5
7493 : #endif
7494 : use pm_kind, only: TKR => IK, CKC => CK5
7495 : complex(CKC) , intent(in) , contiguous :: array(:)
7496 : procedure(logical(LK)) :: isSorted
7497 : integer(TKR) :: rank(size(array, kind = IK))
7498 : end function
7499 : #endif
7500 :
7501 : #if CK4_ENABLED
7502 : module function getRankOrdinalCusCom_D1_CK4(array, isSorted) result(rank)
7503 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7504 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_CK4
7505 : #endif
7506 : use pm_kind, only: TKR => IK, CKC => CK4
7507 : complex(CKC) , intent(in) , contiguous :: array(:)
7508 : procedure(logical(LK)) :: isSorted
7509 : integer(TKR) :: rank(size(array, kind = IK))
7510 : end function
7511 : #endif
7512 :
7513 : #if CK3_ENABLED
7514 : module function getRankOrdinalCusCom_D1_CK3(array, isSorted) result(rank)
7515 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7516 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_CK3
7517 : #endif
7518 : use pm_kind, only: TKR => IK, CKC => CK3
7519 : complex(CKC) , intent(in) , contiguous :: array(:)
7520 : procedure(logical(LK)) :: isSorted
7521 : integer(TKR) :: rank(size(array, kind = IK))
7522 : end function
7523 : #endif
7524 :
7525 : #if CK2_ENABLED
7526 : module function getRankOrdinalCusCom_D1_CK2(array, isSorted) result(rank)
7527 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7528 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_CK2
7529 : #endif
7530 : use pm_kind, only: TKR => IK, CKC => CK2
7531 : complex(CKC) , intent(in) , contiguous :: array(:)
7532 : procedure(logical(LK)) :: isSorted
7533 : integer(TKR) :: rank(size(array, kind = IK))
7534 : end function
7535 : #endif
7536 :
7537 : #if CK1_ENABLED
7538 : module function getRankOrdinalCusCom_D1_CK1(array, isSorted) result(rank)
7539 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7540 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_CK1
7541 : #endif
7542 : use pm_kind, only: TKR => IK, CKC => CK1
7543 : complex(CKC) , intent(in) , contiguous :: array(:)
7544 : procedure(logical(LK)) :: isSorted
7545 : integer(TKR) :: rank(size(array, kind = IK))
7546 : end function
7547 : #endif
7548 :
7549 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7550 :
7551 : #if RK5_ENABLED
7552 : module function getRankOrdinalCusCom_D1_RK5(array, isSorted) result(rank)
7553 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7554 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_RK5
7555 : #endif
7556 : use pm_kind, only: TKR => IK, RKC => RK5
7557 : real(RKC) , intent(in) , contiguous :: array(:)
7558 : procedure(logical(LK)) :: isSorted
7559 : integer(TKR) :: rank(size(array, kind = IK))
7560 : end function
7561 : #endif
7562 :
7563 : #if RK4_ENABLED
7564 : module function getRankOrdinalCusCom_D1_RK4(array, isSorted) result(rank)
7565 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7566 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_RK4
7567 : #endif
7568 : use pm_kind, only: TKR => IK, RKC => RK4
7569 : real(RKC) , intent(in) , contiguous :: array(:)
7570 : procedure(logical(LK)) :: isSorted
7571 : integer(TKR) :: rank(size(array, kind = IK))
7572 : end function
7573 : #endif
7574 :
7575 : #if RK3_ENABLED
7576 : module function getRankOrdinalCusCom_D1_RK3(array, isSorted) result(rank)
7577 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7578 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_RK3
7579 : #endif
7580 : use pm_kind, only: TKR => IK, RKC => RK3
7581 : real(RKC) , intent(in) , contiguous :: array(:)
7582 : procedure(logical(LK)) :: isSorted
7583 : integer(TKR) :: rank(size(array, kind = IK))
7584 : end function
7585 : #endif
7586 :
7587 : #if RK2_ENABLED
7588 : module function getRankOrdinalCusCom_D1_RK2(array, isSorted) result(rank)
7589 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7590 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_RK2
7591 : #endif
7592 : use pm_kind, only: TKR => IK, RKC => RK2
7593 : real(RKC) , intent(in) , contiguous :: array(:)
7594 : procedure(logical(LK)) :: isSorted
7595 : integer(TKR) :: rank(size(array, kind = IK))
7596 : end function
7597 : #endif
7598 :
7599 : #if RK1_ENABLED
7600 : module function getRankOrdinalCusCom_D1_RK1(array, isSorted) result(rank)
7601 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7602 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_RK1
7603 : #endif
7604 : use pm_kind, only: TKR => IK, RKC => RK1
7605 : real(RKC) , intent(in) , contiguous :: array(:)
7606 : procedure(logical(LK)) :: isSorted
7607 : integer(TKR) :: rank(size(array, kind = IK))
7608 : end function
7609 : #endif
7610 :
7611 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7612 :
7613 : #if SK5_ENABLED
7614 : module function getRankOrdinalCusCom_D1_PSSK5(array, isSorted) result(rank)
7615 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7616 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_PSSK5
7617 : #endif
7618 : use pm_kind, only: TKR => IK, SKC => SK5
7619 : use pm_container, only: css_pdt
7620 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7621 : procedure(logical(LK)) :: isSorted
7622 : integer(TKR) :: rank(size(array, kind = IK))
7623 : end function
7624 : #endif
7625 :
7626 : #if SK4_ENABLED
7627 : module function getRankOrdinalCusCom_D1_PSSK4(array, isSorted) result(rank)
7628 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7629 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_PSSK4
7630 : #endif
7631 : use pm_kind, only: TKR => IK, SKC => SK4
7632 : use pm_container, only: css_pdt
7633 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7634 : procedure(logical(LK)) :: isSorted
7635 : integer(TKR) :: rank(size(array, kind = IK))
7636 : end function
7637 : #endif
7638 :
7639 : #if SK3_ENABLED
7640 : module function getRankOrdinalCusCom_D1_PSSK3(array, isSorted) result(rank)
7641 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7642 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_PSSK3
7643 : #endif
7644 : use pm_kind, only: TKR => IK, SKC => SK3
7645 : use pm_container, only: css_pdt
7646 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7647 : procedure(logical(LK)) :: isSorted
7648 : integer(TKR) :: rank(size(array, kind = IK))
7649 : end function
7650 : #endif
7651 :
7652 : #if SK2_ENABLED
7653 : module function getRankOrdinalCusCom_D1_PSSK2(array, isSorted) result(rank)
7654 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7655 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_PSSK2
7656 : #endif
7657 : use pm_kind, only: TKR => IK, SKC => SK2
7658 : use pm_container, only: css_pdt
7659 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7660 : procedure(logical(LK)) :: isSorted
7661 : integer(TKR) :: rank(size(array, kind = IK))
7662 : end function
7663 : #endif
7664 :
7665 : #if SK1_ENABLED
7666 : module function getRankOrdinalCusCom_D1_PSSK1(array, isSorted) result(rank)
7667 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7668 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_PSSK1
7669 : #endif
7670 : use pm_kind, only: TKR => IK, SKC => SK1
7671 : use pm_container, only: css_pdt
7672 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
7673 : integer(TKR) :: rank(size(array, kind = IK))
7674 : procedure(logical(LK)) :: isSorted
7675 : end function
7676 : #endif
7677 :
7678 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7679 :
7680 : module function getRankOrdinalCusCom_D1_BSSK(array, isSorted) result(rank)
7681 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7682 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankOrdinalCusCom_D1_BSSK
7683 : #endif
7684 : use pm_kind, only: TKR => IK, SKC => SK
7685 : use pm_container, only: css_type
7686 : type(css_type) , intent(in) , contiguous :: array(:)
7687 : procedure(logical(LK)) :: isSorted
7688 : integer(TKR) :: rank(size(array, kind = IK))
7689 : end function
7690 :
7691 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7692 :
7693 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7694 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7695 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7696 :
7697 : end interface
7698 :
7699 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7700 :
7701 : !> \brief
7702 : !> Return the **ordinal rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
7703 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
7704 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
7705 : !>
7706 : !> \details
7707 : !> This kind of ranking of values is widely known as <b>ordinal (`1234`) ranking</b>.<br>
7708 : !> In ordinal ranking, all items receive distinct ordinal numbers, including items that compare equal.<br>
7709 : !> The assignment of distinct ordinal numbers to items that compare equal can be done at random, or arbitrarily,
7710 : !> but it is generally preferable to use a system that is arbitrary but consistent,
7711 : !> as this gives stable results if the ranking is done multiple times.<br>
7712 : !> In computer data processing, ordinal ranking is also referred to as **row numbering**.
7713 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **ordinal ranking** `1234`.<br>
7714 : !>
7715 : !> \param[out] rank : The output `contiguous` array of rank `1` of type `integer` of default kind \IK
7716 : !> containing the ranks of the corresponding elements of `array`.<br>
7717 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
7718 : !> **Read `rank(i)` as the ordinal rank of the `i`th element of `array`.**
7719 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
7720 : !> <ol>
7721 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
7722 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
7723 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
7724 : !> <li> type `integer` of kind \IKALL or,<br>
7725 : !> <li> type `logical` of kind \LKALL or,<br>
7726 : !> <li> type `complex` of kind \CKALL or,<br>
7727 : !> <li> type `real` of kind \RKALL,<br>
7728 : !> </ol>
7729 : !> or,
7730 : !> <ol>
7731 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
7732 : !> </ol>
7733 : !> whose elements rankings will be computed and returned.
7734 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type and kind as the input `array`.<br>
7735 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
7736 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
7737 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
7738 : !> If `array` is a Fortran string (i.e., a scalar `character`),
7739 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
7740 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
7741 : !> \code{.F90}
7742 : !> function isSorted(a,b) result (sorted)
7743 : !> use pm_kind, only: SK, IK, LK, CK, RK
7744 : !> TYPE(KIND) , intent(in) :: a, b
7745 : !> logical(LK) :: sorted
7746 : !> end function
7747 : !> \endcode
7748 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
7749 : !> \code{.F90}
7750 : !> use pm_container, only: StrCon
7751 : !> use pm_kind, only: SK, IK, LK, CK, RK
7752 : !> character(*, SK), intent(in) :: a, b
7753 : !> integer(IK) , intent(in) :: a, b
7754 : !> logical(LK) , intent(in) :: a, b
7755 : !> complex(CK) , intent(in) :: a, b
7756 : !> real(RK) , intent(in) :: a, b
7757 : !> type(StrCon) , intent(in) :: a, b
7758 : !> \endcode
7759 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
7760 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
7761 : !> \code{.F90}
7762 : !> function isSorted(a,b) result (sorted)
7763 : !> character(1,SKC), intent(in) :: a, b
7764 : !> logical(LK) :: sorted
7765 : !> end function
7766 : !> \endcode
7767 : !> where `SKC` represents the kind of the input string argument `array`.<br>
7768 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
7769 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
7770 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
7771 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
7772 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
7773 : !>
7774 : !> \interface{setRankOrdinal}
7775 : !> \code{.F90}
7776 : !>
7777 : !> use pm_arrayRank, only: setRankOrdinal
7778 : !>
7779 : !> call setRankOrdinal(rank, array)
7780 : !> call setRankOrdinal(rank, array, isSorted)
7781 : !>
7782 : !> \endcode
7783 : !>
7784 : !> \warning
7785 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
7786 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
7787 : !> identify ties within the Standard ranking of the input `array`.
7788 : !>
7789 : !> \warnpure
7790 : !>
7791 : !> \warning
7792 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
7793 : !>
7794 : !> \see
7795 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
7796 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
7797 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
7798 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
7799 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
7800 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
7801 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
7802 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
7803 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
7804 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
7805 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
7806 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
7807 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
7808 : !>
7809 : !> \example{setRankOrdinal}
7810 : !> \include{lineno} example/pm_arrayRank/setRankOrdinal/main.F90
7811 : !> \compilef{setRankOrdinal}
7812 : !> \output{setRankOrdinal}
7813 : !> \include{lineno} example/pm_arrayRank/setRankOrdinal/main.out.F90
7814 : !>
7815 : !> \test
7816 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
7817 : !>
7818 : !> \bug
7819 : !> \status \unresolved
7820 : !> \source \ifort{2021.5}
7821 : !> \desc
7822 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
7823 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
7824 : !> \remedy
7825 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
7826 : !>
7827 : !> \todo
7828 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
7829 : !>
7830 : !> \todo
7831 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
7832 : !>
7833 : !> \finmain{setRankOrdinal}
7834 : !>
7835 : !> \author
7836 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
7837 : interface setRankOrdinal
7838 :
7839 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7840 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7841 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7842 :
7843 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7844 :
7845 : #if SK5_ENABLED
7846 : PURE module subroutine setRankOrdinalDefCom_D0_SK5(rank, array)
7847 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7848 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D0_SK5
7849 : #endif
7850 : use pm_kind, only: TKR => IK, SKC => SK5
7851 : character(*,SKC) , intent(in) :: array
7852 : integer(TKR) , intent(out) , contiguous :: rank(:)
7853 : end subroutine
7854 : #endif
7855 :
7856 : #if SK4_ENABLED
7857 : PURE module subroutine setRankOrdinalDefCom_D0_SK4(rank, array)
7858 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7859 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D0_SK4
7860 : #endif
7861 : use pm_kind, only: TKR => IK, SKC => SK4
7862 : character(*,SKC) , intent(in) :: array
7863 : integer(TKR) , intent(out) , contiguous :: rank(:)
7864 : end subroutine
7865 : #endif
7866 :
7867 : #if SK3_ENABLED
7868 : PURE module subroutine setRankOrdinalDefCom_D0_SK3(rank, array)
7869 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7870 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D0_SK3
7871 : #endif
7872 : use pm_kind, only: TKR => IK, SKC => SK3
7873 : character(*,SKC) , intent(in) :: array
7874 : integer(TKR) , intent(out) , contiguous :: rank(:)
7875 : end subroutine
7876 : #endif
7877 :
7878 : #if SK2_ENABLED
7879 : PURE module subroutine setRankOrdinalDefCom_D0_SK2(rank, array)
7880 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7881 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D0_SK2
7882 : #endif
7883 : use pm_kind, only: TKR => IK, SKC => SK2
7884 : character(*,SKC) , intent(in) :: array
7885 : integer(TKR) , intent(out) , contiguous :: rank(:)
7886 : end subroutine
7887 : #endif
7888 :
7889 : #if SK1_ENABLED
7890 : PURE module subroutine setRankOrdinalDefCom_D0_SK1(rank, array)
7891 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7892 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D0_SK1
7893 : #endif
7894 : use pm_kind, only: TKR => IK, SKC => SK1
7895 : character(*,SKC) , intent(in) :: array
7896 : integer(TKR) , intent(out) , contiguous :: rank(:)
7897 : end subroutine
7898 : #endif
7899 :
7900 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7901 :
7902 : #if SK5_ENABLED
7903 : PURE module subroutine setRankOrdinalDefCom_D1_SK5(rank, array)
7904 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7905 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_SK5
7906 : #endif
7907 : use pm_kind, only: TKR => IK, SKC => SK5
7908 : character(*,SKC) , intent(in) , contiguous :: array(:)
7909 : integer(TKR) , intent(out) , contiguous :: rank(:)
7910 : end subroutine
7911 : #endif
7912 :
7913 : #if SK4_ENABLED
7914 : PURE module subroutine setRankOrdinalDefCom_D1_SK4(rank, array)
7915 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7916 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_SK4
7917 : #endif
7918 : use pm_kind, only: TKR => IK, SKC => SK4
7919 : character(*,SKC) , intent(in) , contiguous :: array(:)
7920 : integer(TKR) , intent(out) , contiguous :: rank(:)
7921 : end subroutine
7922 : #endif
7923 :
7924 : #if SK3_ENABLED
7925 : PURE module subroutine setRankOrdinalDefCom_D1_SK3(rank, array)
7926 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7927 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_SK3
7928 : #endif
7929 : use pm_kind, only: TKR => IK, SKC => SK3
7930 : character(*,SKC) , intent(in) , contiguous :: array(:)
7931 : integer(TKR) , intent(out) , contiguous :: rank(:)
7932 : end subroutine
7933 : #endif
7934 :
7935 : #if SK2_ENABLED
7936 : PURE module subroutine setRankOrdinalDefCom_D1_SK2(rank, array)
7937 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7938 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_SK2
7939 : #endif
7940 : use pm_kind, only: TKR => IK, SKC => SK2
7941 : character(*,SKC) , intent(in) , contiguous :: array(:)
7942 : integer(TKR) , intent(out) , contiguous :: rank(:)
7943 : end subroutine
7944 : #endif
7945 :
7946 : #if SK1_ENABLED
7947 : PURE module subroutine setRankOrdinalDefCom_D1_SK1(rank, array)
7948 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7949 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_SK1
7950 : #endif
7951 : use pm_kind, only: TKR => IK, SKC => SK1
7952 : character(*,SKC) , intent(in) , contiguous :: array(:)
7953 : integer(TKR) , intent(out) , contiguous :: rank(:)
7954 : end subroutine
7955 : #endif
7956 :
7957 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
7958 :
7959 : #if IK5_ENABLED
7960 : PURE module subroutine setRankOrdinalDefCom_D1_IK5(rank, array)
7961 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7962 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_IK5
7963 : #endif
7964 : use pm_kind, only: TKR => IK, IKC => IK5
7965 : integer(IKC) , intent(in) , contiguous :: array(:)
7966 : integer(TKR) , intent(out) , contiguous :: rank(:)
7967 : end subroutine
7968 : #endif
7969 :
7970 : #if IK4_ENABLED
7971 : PURE module subroutine setRankOrdinalDefCom_D1_IK4(rank, array)
7972 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7973 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_IK4
7974 : #endif
7975 : use pm_kind, only: TKR => IK, IKC => IK4
7976 : integer(IKC) , intent(in) , contiguous :: array(:)
7977 : integer(TKR) , intent(out) , contiguous :: rank(:)
7978 : end subroutine
7979 : #endif
7980 :
7981 : #if IK3_ENABLED
7982 : PURE module subroutine setRankOrdinalDefCom_D1_IK3(rank, array)
7983 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7984 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_IK3
7985 : #endif
7986 : use pm_kind, only: TKR => IK, IKC => IK3
7987 : integer(IKC) , intent(in) , contiguous :: array(:)
7988 : integer(TKR) , intent(out) , contiguous :: rank(:)
7989 : end subroutine
7990 : #endif
7991 :
7992 : #if IK2_ENABLED
7993 : PURE module subroutine setRankOrdinalDefCom_D1_IK2(rank, array)
7994 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
7995 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_IK2
7996 : #endif
7997 : use pm_kind, only: TKR => IK, IKC => IK2
7998 : integer(IKC) , intent(in) , contiguous :: array(:)
7999 : integer(TKR) , intent(out) , contiguous :: rank(:)
8000 : end subroutine
8001 : #endif
8002 :
8003 : #if IK1_ENABLED
8004 : PURE module subroutine setRankOrdinalDefCom_D1_IK1(rank, array)
8005 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8006 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_IK1
8007 : #endif
8008 : use pm_kind, only: TKR => IK, IKC => IK1
8009 : integer(IKC) , intent(in) , contiguous :: array(:)
8010 : integer(TKR) , intent(out) , contiguous :: rank(:)
8011 : end subroutine
8012 : #endif
8013 :
8014 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8015 :
8016 : #if LK5_ENABLED
8017 : PURE module subroutine setRankOrdinalDefCom_D1_LK5(rank, array)
8018 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8019 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_LK5
8020 : #endif
8021 : use pm_kind, only: TKR => IK, LKC => LK5
8022 : logical(LKC) , intent(in) , contiguous :: array(:)
8023 : integer(TKR) , intent(out) , contiguous :: rank(:)
8024 : end subroutine
8025 : #endif
8026 :
8027 : #if LK4_ENABLED
8028 : PURE module subroutine setRankOrdinalDefCom_D1_LK4(rank, array)
8029 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8030 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_LK4
8031 : #endif
8032 : use pm_kind, only: TKR => IK, LKC => LK4
8033 : logical(LKC) , intent(in) , contiguous :: array(:)
8034 : integer(TKR) , intent(out) , contiguous :: rank(:)
8035 : end subroutine
8036 : #endif
8037 :
8038 : #if LK3_ENABLED
8039 : PURE module subroutine setRankOrdinalDefCom_D1_LK3(rank, array)
8040 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8041 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_LK3
8042 : #endif
8043 : use pm_kind, only: TKR => IK, LKC => LK3
8044 : logical(LKC) , intent(in) , contiguous :: array(:)
8045 : integer(TKR) , intent(out) , contiguous :: rank(:)
8046 : end subroutine
8047 : #endif
8048 :
8049 : #if LK2_ENABLED
8050 : PURE module subroutine setRankOrdinalDefCom_D1_LK2(rank, array)
8051 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8052 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_LK2
8053 : #endif
8054 : use pm_kind, only: TKR => IK, LKC => LK2
8055 : logical(LKC) , intent(in) , contiguous :: array(:)
8056 : integer(TKR) , intent(out) , contiguous :: rank(:)
8057 : end subroutine
8058 : #endif
8059 :
8060 : #if LK1_ENABLED
8061 : PURE module subroutine setRankOrdinalDefCom_D1_LK1(rank, array)
8062 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8063 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_LK1
8064 : #endif
8065 : use pm_kind, only: TKR => IK, LKC => LK1
8066 : logical(LKC) , intent(in) , contiguous :: array(:)
8067 : integer(TKR) , intent(out) , contiguous :: rank(:)
8068 : end subroutine
8069 : #endif
8070 :
8071 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8072 :
8073 : #if CK5_ENABLED
8074 : PURE module subroutine setRankOrdinalDefCom_D1_CK5(rank, array)
8075 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8076 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_CK5
8077 : #endif
8078 : use pm_kind, only: TKR => IK, CKC => CK5
8079 : complex(CKC) , intent(in) , contiguous :: array(:)
8080 : integer(TKR) , intent(out) , contiguous :: rank(:)
8081 : end subroutine
8082 : #endif
8083 :
8084 : #if CK4_ENABLED
8085 : PURE module subroutine setRankOrdinalDefCom_D1_CK4(rank, array)
8086 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8087 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_CK4
8088 : #endif
8089 : use pm_kind, only: TKR => IK, CKC => CK4
8090 : complex(CKC) , intent(in) , contiguous :: array(:)
8091 : integer(TKR) , intent(out) , contiguous :: rank(:)
8092 : end subroutine
8093 : #endif
8094 :
8095 : #if CK3_ENABLED
8096 : PURE module subroutine setRankOrdinalDefCom_D1_CK3(rank, array)
8097 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8098 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_CK3
8099 : #endif
8100 : use pm_kind, only: TKR => IK, CKC => CK3
8101 : complex(CKC) , intent(in) , contiguous :: array(:)
8102 : integer(TKR) , intent(out) , contiguous :: rank(:)
8103 : end subroutine
8104 : #endif
8105 :
8106 : #if CK2_ENABLED
8107 : PURE module subroutine setRankOrdinalDefCom_D1_CK2(rank, array)
8108 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8109 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_CK2
8110 : #endif
8111 : use pm_kind, only: TKR => IK, CKC => CK2
8112 : complex(CKC) , intent(in) , contiguous :: array(:)
8113 : integer(TKR) , intent(out) , contiguous :: rank(:)
8114 : end subroutine
8115 : #endif
8116 :
8117 : #if CK1_ENABLED
8118 : PURE module subroutine setRankOrdinalDefCom_D1_CK1(rank, array)
8119 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8120 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_CK1
8121 : #endif
8122 : use pm_kind, only: TKR => IK, CKC => CK1
8123 : complex(CKC) , intent(in) , contiguous :: array(:)
8124 : integer(TKR) , intent(out) , contiguous :: rank(:)
8125 : end subroutine
8126 : #endif
8127 :
8128 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8129 :
8130 : #if RK5_ENABLED
8131 : PURE module subroutine setRankOrdinalDefCom_D1_RK5(rank, array)
8132 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8133 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_RK5
8134 : #endif
8135 : use pm_kind, only: TKR => IK, RKC => RK5
8136 : real(RKC) , intent(in) , contiguous :: array(:)
8137 : integer(TKR) , intent(out) , contiguous :: rank(:)
8138 : end subroutine
8139 : #endif
8140 :
8141 : #if RK4_ENABLED
8142 : PURE module subroutine setRankOrdinalDefCom_D1_RK4(rank, array)
8143 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8144 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_RK4
8145 : #endif
8146 : use pm_kind, only: TKR => IK, RKC => RK4
8147 : real(RKC) , intent(in) , contiguous :: array(:)
8148 : integer(TKR) , intent(out) , contiguous :: rank(:)
8149 : end subroutine
8150 : #endif
8151 :
8152 : #if RK3_ENABLED
8153 : PURE module subroutine setRankOrdinalDefCom_D1_RK3(rank, array)
8154 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8155 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_RK3
8156 : #endif
8157 : use pm_kind, only: TKR => IK, RKC => RK3
8158 : real(RKC) , intent(in) , contiguous :: array(:)
8159 : integer(TKR) , intent(out) , contiguous :: rank(:)
8160 : end subroutine
8161 : #endif
8162 :
8163 : #if RK2_ENABLED
8164 : PURE module subroutine setRankOrdinalDefCom_D1_RK2(rank, array)
8165 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8166 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_RK2
8167 : #endif
8168 : use pm_kind, only: TKR => IK, RKC => RK2
8169 : real(RKC) , intent(in) , contiguous :: array(:)
8170 : integer(TKR) , intent(out) , contiguous :: rank(:)
8171 : end subroutine
8172 : #endif
8173 :
8174 : #if RK1_ENABLED
8175 : PURE module subroutine setRankOrdinalDefCom_D1_RK1(rank, array)
8176 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8177 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_RK1
8178 : #endif
8179 : use pm_kind, only: TKR => IK, RKC => RK1
8180 : real(RKC) , intent(in) , contiguous :: array(:)
8181 : integer(TKR) , intent(out) , contiguous :: rank(:)
8182 : end subroutine
8183 : #endif
8184 :
8185 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8186 :
8187 : #if SK5_ENABLED
8188 : PURE module subroutine setRankOrdinalDefCom_D1_PSSK5(rank, array)
8189 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8190 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_PSSK5
8191 : #endif
8192 : use pm_kind, only: TKR => IK, SKC => SK5
8193 : use pm_container, only: css_pdt
8194 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8195 : integer(TKR) , intent(out) , contiguous :: rank(:)
8196 : end subroutine
8197 : #endif
8198 :
8199 : #if SK4_ENABLED
8200 : PURE module subroutine setRankOrdinalDefCom_D1_PSSK4(rank, array)
8201 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8202 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_PSSK4
8203 : #endif
8204 : use pm_kind, only: TKR => IK, SKC => SK4
8205 : use pm_container, only: css_pdt
8206 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8207 : integer(TKR) , intent(out) , contiguous :: rank(:)
8208 : end subroutine
8209 : #endif
8210 :
8211 : #if SK3_ENABLED
8212 : PURE module subroutine setRankOrdinalDefCom_D1_PSSK3(rank, array)
8213 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8214 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_PSSK3
8215 : #endif
8216 : use pm_kind, only: TKR => IK, SKC => SK3
8217 : use pm_container, only: css_pdt
8218 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8219 : integer(TKR) , intent(out) , contiguous :: rank(:)
8220 : end subroutine
8221 : #endif
8222 :
8223 : #if SK2_ENABLED
8224 : PURE module subroutine setRankOrdinalDefCom_D1_PSSK2(rank, array)
8225 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8226 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_PSSK2
8227 : #endif
8228 : use pm_kind, only: TKR => IK, SKC => SK2
8229 : use pm_container, only: css_pdt
8230 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8231 : integer(TKR) , intent(out) , contiguous :: rank(:)
8232 : end subroutine
8233 : #endif
8234 :
8235 : #if SK1_ENABLED
8236 : PURE module subroutine setRankOrdinalDefCom_D1_PSSK1(rank, array)
8237 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8238 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_PSSK1
8239 : #endif
8240 : use pm_kind, only: TKR => IK, SKC => SK1
8241 : use pm_container, only: css_pdt
8242 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8243 : integer(TKR) , intent(out) , contiguous :: rank(:)
8244 : end subroutine
8245 : #endif
8246 :
8247 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8248 :
8249 : PURE module subroutine setRankOrdinalDefCom_D1_BSSK(rank, array)
8250 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8251 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalDefCom_D1_BSSK
8252 : #endif
8253 : use pm_kind, only: TKR => IK, SKC => SK
8254 : use pm_container, only: css_type
8255 : type(css_type) , intent(in) , contiguous :: array(:)
8256 : integer(TKR) , intent(out) , contiguous :: rank(:)
8257 : end subroutine
8258 :
8259 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8260 :
8261 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8262 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8263 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8264 :
8265 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8266 :
8267 : #if SK5_ENABLED
8268 : module subroutine setRankOrdinalCusCom_D0_SK5(rank, array, isSorted)
8269 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8270 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D0_SK5
8271 : #endif
8272 : use pm_kind, only: TKR => IK, SKC => SK5
8273 : character(*,SKC) , intent(in) :: array
8274 : integer(TKR) , intent(out) , contiguous :: rank(:)
8275 : procedure(logical(LK)) :: isSorted
8276 : end subroutine
8277 : #endif
8278 :
8279 : #if SK4_ENABLED
8280 : module subroutine setRankOrdinalCusCom_D0_SK4(rank, array, isSorted)
8281 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8282 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D0_SK4
8283 : #endif
8284 : use pm_kind, only: TKR => IK, SKC => SK4
8285 : character(*,SKC) , intent(in) :: array
8286 : integer(TKR) , intent(out) , contiguous :: rank(:)
8287 : procedure(logical(LK)) :: isSorted
8288 : end subroutine
8289 : #endif
8290 :
8291 : #if SK3_ENABLED
8292 : module subroutine setRankOrdinalCusCom_D0_SK3(rank, array, isSorted)
8293 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8294 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D0_SK3
8295 : #endif
8296 : use pm_kind, only: TKR => IK, SKC => SK3
8297 : character(*,SKC) , intent(in) :: array
8298 : integer(TKR) , intent(out) , contiguous :: rank(:)
8299 : procedure(logical(LK)) :: isSorted
8300 : end subroutine
8301 : #endif
8302 :
8303 : #if SK2_ENABLED
8304 : module subroutine setRankOrdinalCusCom_D0_SK2(rank, array, isSorted)
8305 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8306 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D0_SK2
8307 : #endif
8308 : use pm_kind, only: TKR => IK, SKC => SK2
8309 : character(*,SKC) , intent(in) :: array
8310 : integer(TKR) , intent(out) , contiguous :: rank(:)
8311 : procedure(logical(LK)) :: isSorted
8312 : end subroutine
8313 : #endif
8314 :
8315 : #if SK1_ENABLED
8316 : module subroutine setRankOrdinalCusCom_D0_SK1(rank, array, isSorted)
8317 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8318 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D0_SK1
8319 : #endif
8320 : use pm_kind, only: TKR => IK, SKC => SK1
8321 : character(*,SKC) , intent(in) :: array
8322 : integer(TKR) , intent(out) , contiguous :: rank(:)
8323 : procedure(logical(LK)) :: isSorted
8324 : end subroutine
8325 : #endif
8326 :
8327 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8328 :
8329 : #if SK5_ENABLED
8330 : module subroutine setRankOrdinalCusCom_D1_SK5(rank, array, isSorted)
8331 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8332 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_SK5
8333 : #endif
8334 : use pm_kind, only: TKR => IK, SKC => SK5
8335 : character(*,SKC) , intent(in) , contiguous :: array(:)
8336 : integer(TKR) , intent(out) , contiguous :: rank(:)
8337 : procedure(logical(LK)) :: isSorted
8338 : end subroutine
8339 : #endif
8340 :
8341 : #if SK4_ENABLED
8342 : module subroutine setRankOrdinalCusCom_D1_SK4(rank, array, isSorted)
8343 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8344 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_SK4
8345 : #endif
8346 : use pm_kind, only: TKR => IK, SKC => SK4
8347 : character(*,SKC) , intent(in) , contiguous :: array(:)
8348 : integer(TKR) , intent(out) , contiguous :: rank(:)
8349 : procedure(logical(LK)) :: isSorted
8350 : end subroutine
8351 : #endif
8352 :
8353 : #if SK3_ENABLED
8354 : module subroutine setRankOrdinalCusCom_D1_SK3(rank, array, isSorted)
8355 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8356 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_SK3
8357 : #endif
8358 : use pm_kind, only: TKR => IK, SKC => SK3
8359 : character(*,SKC) , intent(in) , contiguous :: array(:)
8360 : integer(TKR) , intent(out) , contiguous :: rank(:)
8361 : procedure(logical(LK)) :: isSorted
8362 : end subroutine
8363 : #endif
8364 :
8365 : #if SK2_ENABLED
8366 : module subroutine setRankOrdinalCusCom_D1_SK2(rank, array, isSorted)
8367 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8368 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_SK2
8369 : #endif
8370 : use pm_kind, only: TKR => IK, SKC => SK2
8371 : character(*,SKC) , intent(in) , contiguous :: array(:)
8372 : integer(TKR) , intent(out) , contiguous :: rank(:)
8373 : procedure(logical(LK)) :: isSorted
8374 : end subroutine
8375 : #endif
8376 :
8377 : #if SK1_ENABLED
8378 : module subroutine setRankOrdinalCusCom_D1_SK1(rank, array, isSorted)
8379 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8380 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_SK1
8381 : #endif
8382 : use pm_kind, only: TKR => IK, SKC => SK1
8383 : character(*,SKC) , intent(in) , contiguous :: array(:)
8384 : integer(TKR) , intent(out) , contiguous :: rank(:)
8385 : procedure(logical(LK)) :: isSorted
8386 : end subroutine
8387 : #endif
8388 :
8389 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8390 :
8391 : #if IK5_ENABLED
8392 : module subroutine setRankOrdinalCusCom_D1_IK5(rank, array, isSorted)
8393 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8394 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_IK5
8395 : #endif
8396 : use pm_kind, only: TKR => IK, IKC => IK5
8397 : integer(IKC) , intent(in) , contiguous :: array(:)
8398 : integer(TKR) , intent(out) , contiguous :: rank(:)
8399 : procedure(logical(LK)) :: isSorted
8400 : end subroutine
8401 : #endif
8402 :
8403 : #if IK4_ENABLED
8404 : module subroutine setRankOrdinalCusCom_D1_IK4(rank, array, isSorted)
8405 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8406 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_IK4
8407 : #endif
8408 : use pm_kind, only: TKR => IK, IKC => IK4
8409 : integer(IKC) , intent(in) , contiguous :: array(:)
8410 : integer(TKR) , intent(out) , contiguous :: rank(:)
8411 : procedure(logical(LK)) :: isSorted
8412 : end subroutine
8413 : #endif
8414 :
8415 : #if IK3_ENABLED
8416 : module subroutine setRankOrdinalCusCom_D1_IK3(rank, array, isSorted)
8417 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8418 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_IK3
8419 : #endif
8420 : use pm_kind, only: TKR => IK, IKC => IK3
8421 : integer(IKC) , intent(in) , contiguous :: array(:)
8422 : integer(TKR) , intent(out) , contiguous :: rank(:)
8423 : procedure(logical(LK)) :: isSorted
8424 : end subroutine
8425 : #endif
8426 :
8427 : #if IK2_ENABLED
8428 : module subroutine setRankOrdinalCusCom_D1_IK2(rank, array, isSorted)
8429 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8430 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_IK2
8431 : #endif
8432 : use pm_kind, only: TKR => IK, IKC => IK2
8433 : integer(IKC) , intent(in) , contiguous :: array(:)
8434 : integer(TKR) , intent(out) , contiguous :: rank(:)
8435 : procedure(logical(LK)) :: isSorted
8436 : end subroutine
8437 : #endif
8438 :
8439 : #if IK1_ENABLED
8440 : module subroutine setRankOrdinalCusCom_D1_IK1(rank, array, isSorted)
8441 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8442 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_IK1
8443 : #endif
8444 : use pm_kind, only: TKR => IK, IKC => IK1
8445 : integer(IKC) , intent(in) , contiguous :: array(:)
8446 : integer(TKR) , intent(out) , contiguous :: rank(:)
8447 : procedure(logical(LK)) :: isSorted
8448 : end subroutine
8449 : #endif
8450 :
8451 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8452 :
8453 : #if LK5_ENABLED
8454 : module subroutine setRankOrdinalCusCom_D1_LK5(rank, array, isSorted)
8455 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8456 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_LK5
8457 : #endif
8458 : use pm_kind, only: TKR => IK, LKC => LK5
8459 : logical(LKC) , intent(in) , contiguous :: array(:)
8460 : integer(TKR) , intent(out) , contiguous :: rank(:)
8461 : procedure(logical(LK)) :: isSorted
8462 : end subroutine
8463 : #endif
8464 :
8465 : #if LK4_ENABLED
8466 : module subroutine setRankOrdinalCusCom_D1_LK4(rank, array, isSorted)
8467 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8468 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_LK4
8469 : #endif
8470 : use pm_kind, only: TKR => IK, LKC => LK4
8471 : logical(LKC) , intent(in) , contiguous :: array(:)
8472 : integer(TKR) , intent(out) , contiguous :: rank(:)
8473 : procedure(logical(LK)) :: isSorted
8474 : end subroutine
8475 : #endif
8476 :
8477 : #if LK3_ENABLED
8478 : module subroutine setRankOrdinalCusCom_D1_LK3(rank, array, isSorted)
8479 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8480 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_LK3
8481 : #endif
8482 : use pm_kind, only: TKR => IK, LKC => LK3
8483 : logical(LKC) , intent(in) , contiguous :: array(:)
8484 : integer(TKR) , intent(out) , contiguous :: rank(:)
8485 : procedure(logical(LK)) :: isSorted
8486 : end subroutine
8487 : #endif
8488 :
8489 : #if LK2_ENABLED
8490 : module subroutine setRankOrdinalCusCom_D1_LK2(rank, array, isSorted)
8491 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8492 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_LK2
8493 : #endif
8494 : use pm_kind, only: TKR => IK, LKC => LK2
8495 : logical(LKC) , intent(in) , contiguous :: array(:)
8496 : integer(TKR) , intent(out) , contiguous :: rank(:)
8497 : procedure(logical(LK)) :: isSorted
8498 : end subroutine
8499 : #endif
8500 :
8501 : #if LK1_ENABLED
8502 : module subroutine setRankOrdinalCusCom_D1_LK1(rank, array, isSorted)
8503 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8504 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_LK1
8505 : #endif
8506 : use pm_kind, only: TKR => IK, LKC => LK1
8507 : logical(LKC) , intent(in) , contiguous :: array(:)
8508 : integer(TKR) , intent(out) , contiguous :: rank(:)
8509 : procedure(logical(LK)) :: isSorted
8510 : end subroutine
8511 : #endif
8512 :
8513 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8514 :
8515 : #if CK5_ENABLED
8516 : module subroutine setRankOrdinalCusCom_D1_CK5(rank, array, isSorted)
8517 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8518 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_CK5
8519 : #endif
8520 : use pm_kind, only: TKR => IK, CKC => CK5
8521 : complex(CKC) , intent(in) , contiguous :: array(:)
8522 : integer(TKR) , intent(out) , contiguous :: rank(:)
8523 : procedure(logical(LK)) :: isSorted
8524 : end subroutine
8525 : #endif
8526 :
8527 : #if CK4_ENABLED
8528 : module subroutine setRankOrdinalCusCom_D1_CK4(rank, array, isSorted)
8529 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8530 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_CK4
8531 : #endif
8532 : use pm_kind, only: TKR => IK, CKC => CK4
8533 : complex(CKC) , intent(in) , contiguous :: array(:)
8534 : integer(TKR) , intent(out) , contiguous :: rank(:)
8535 : procedure(logical(LK)) :: isSorted
8536 : end subroutine
8537 : #endif
8538 :
8539 : #if CK3_ENABLED
8540 : module subroutine setRankOrdinalCusCom_D1_CK3(rank, array, isSorted)
8541 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8542 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_CK3
8543 : #endif
8544 : use pm_kind, only: TKR => IK, CKC => CK3
8545 : complex(CKC) , intent(in) , contiguous :: array(:)
8546 : integer(TKR) , intent(out) , contiguous :: rank(:)
8547 : procedure(logical(LK)) :: isSorted
8548 : end subroutine
8549 : #endif
8550 :
8551 : #if CK2_ENABLED
8552 : module subroutine setRankOrdinalCusCom_D1_CK2(rank, array, isSorted)
8553 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8554 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_CK2
8555 : #endif
8556 : use pm_kind, only: TKR => IK, CKC => CK2
8557 : complex(CKC) , intent(in) , contiguous :: array(:)
8558 : integer(TKR) , intent(out) , contiguous :: rank(:)
8559 : procedure(logical(LK)) :: isSorted
8560 : end subroutine
8561 : #endif
8562 :
8563 : #if CK1_ENABLED
8564 : module subroutine setRankOrdinalCusCom_D1_CK1(rank, array, isSorted)
8565 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8566 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_CK1
8567 : #endif
8568 : use pm_kind, only: TKR => IK, CKC => CK1
8569 : complex(CKC) , intent(in) , contiguous :: array(:)
8570 : integer(TKR) , intent(out) , contiguous :: rank(:)
8571 : procedure(logical(LK)) :: isSorted
8572 : end subroutine
8573 : #endif
8574 :
8575 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8576 :
8577 : #if RK5_ENABLED
8578 : module subroutine setRankOrdinalCusCom_D1_RK5(rank, array, isSorted)
8579 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8580 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_RK5
8581 : #endif
8582 : use pm_kind, only: TKR => IK, RKC => RK5
8583 : real(RKC) , intent(in) , contiguous :: array(:)
8584 : integer(TKR) , intent(out) , contiguous :: rank(:)
8585 : procedure(logical(LK)) :: isSorted
8586 : end subroutine
8587 : #endif
8588 :
8589 : #if RK4_ENABLED
8590 : module subroutine setRankOrdinalCusCom_D1_RK4(rank, array, isSorted)
8591 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8592 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_RK4
8593 : #endif
8594 : use pm_kind, only: TKR => IK, RKC => RK4
8595 : real(RKC) , intent(in) , contiguous :: array(:)
8596 : integer(TKR) , intent(out) , contiguous :: rank(:)
8597 : procedure(logical(LK)) :: isSorted
8598 : end subroutine
8599 : #endif
8600 :
8601 : #if RK3_ENABLED
8602 : module subroutine setRankOrdinalCusCom_D1_RK3(rank, array, isSorted)
8603 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8604 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_RK3
8605 : #endif
8606 : use pm_kind, only: TKR => IK, RKC => RK3
8607 : real(RKC) , intent(in) , contiguous :: array(:)
8608 : integer(TKR) , intent(out) , contiguous :: rank(:)
8609 : procedure(logical(LK)) :: isSorted
8610 : end subroutine
8611 : #endif
8612 :
8613 : #if RK2_ENABLED
8614 : module subroutine setRankOrdinalCusCom_D1_RK2(rank, array, isSorted)
8615 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8616 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_RK2
8617 : #endif
8618 : use pm_kind, only: TKR => IK, RKC => RK2
8619 : real(RKC) , intent(in) , contiguous :: array(:)
8620 : integer(TKR) , intent(out) , contiguous :: rank(:)
8621 : procedure(logical(LK)) :: isSorted
8622 : end subroutine
8623 : #endif
8624 :
8625 : #if RK1_ENABLED
8626 : module subroutine setRankOrdinalCusCom_D1_RK1(rank, array, isSorted)
8627 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8628 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_RK1
8629 : #endif
8630 : use pm_kind, only: TKR => IK, RKC => RK1
8631 : real(RKC) , intent(in) , contiguous :: array(:)
8632 : integer(TKR) , intent(out) , contiguous :: rank(:)
8633 : procedure(logical(LK)) :: isSorted
8634 : end subroutine
8635 : #endif
8636 :
8637 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8638 :
8639 : #if SK5_ENABLED
8640 : module subroutine setRankOrdinalCusCom_D1_PSSK5(rank, array, isSorted)
8641 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8642 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_PSSK5
8643 : #endif
8644 : use pm_kind, only: TKR => IK, SKC => SK5
8645 : use pm_container, only: css_pdt
8646 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8647 : integer(TKR) , intent(out) , contiguous :: rank(:)
8648 : procedure(logical(LK)) :: isSorted
8649 : end subroutine
8650 : #endif
8651 :
8652 : #if SK4_ENABLED
8653 : module subroutine setRankOrdinalCusCom_D1_PSSK4(rank, array, isSorted)
8654 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8655 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_PSSK4
8656 : #endif
8657 : use pm_kind, only: TKR => IK, SKC => SK4
8658 : use pm_container, only: css_pdt
8659 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8660 : integer(TKR) , intent(out) , contiguous :: rank(:)
8661 : procedure(logical(LK)) :: isSorted
8662 : end subroutine
8663 : #endif
8664 :
8665 : #if SK3_ENABLED
8666 : module subroutine setRankOrdinalCusCom_D1_PSSK3(rank, array, isSorted)
8667 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8668 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_PSSK3
8669 : #endif
8670 : use pm_kind, only: TKR => IK, SKC => SK3
8671 : use pm_container, only: css_pdt
8672 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8673 : integer(TKR) , intent(out) , contiguous :: rank(:)
8674 : procedure(logical(LK)) :: isSorted
8675 : end subroutine
8676 : #endif
8677 :
8678 : #if SK2_ENABLED
8679 : module subroutine setRankOrdinalCusCom_D1_PSSK2(rank, array, isSorted)
8680 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8681 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_PSSK2
8682 : #endif
8683 : use pm_kind, only: TKR => IK, SKC => SK2
8684 : use pm_container, only: css_pdt
8685 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8686 : integer(TKR) , intent(out) , contiguous :: rank(:)
8687 : procedure(logical(LK)) :: isSorted
8688 : end subroutine
8689 : #endif
8690 :
8691 : #if SK1_ENABLED
8692 : module subroutine setRankOrdinalCusCom_D1_PSSK1(rank, array, isSorted)
8693 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8694 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_PSSK1
8695 : #endif
8696 : use pm_kind, only: TKR => IK, SKC => SK1
8697 : use pm_container, only: css_pdt
8698 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
8699 : integer(TKR) , intent(out) , contiguous :: rank(:)
8700 : procedure(logical(LK)) :: isSorted
8701 : end subroutine
8702 : #endif
8703 :
8704 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8705 :
8706 : module subroutine setRankOrdinalCusCom_D1_BSSK(rank, array, isSorted)
8707 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8708 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankOrdinalCusCom_D1_BSSK
8709 : #endif
8710 : use pm_kind, only: TKR => IK, SKC => SK
8711 : use pm_container, only: css_type
8712 : type(css_type) , intent(in) , contiguous :: array(:)
8713 : integer(TKR) , intent(out) , contiguous :: rank(:)
8714 : procedure(logical(LK)) :: isSorted
8715 : end subroutine
8716 :
8717 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8718 :
8719 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8720 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8721 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8722 :
8723 : end interface
8724 :
8725 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8726 :
8727 : !> \brief
8728 : !> Generate and return the **Standard rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
8729 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
8730 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
8731 : !>
8732 : !> \details
8733 : !> This kind of ranking of values is widely known as <b>Standard Competition (`1224`) ranking</b>.<br>
8734 : !> In Standard Competition ranking, items that compare equal receive the same ranking number,
8735 : !> and then a gap is left in the ranking numbers. The number of ranking numbers that are left out
8736 : !> in this gap is one less than the number of items that compared equal.<br>
8737 : !> Equivalently, the ranking number of each item is `1` plus the number of items ranked above it.<br>
8738 : !> This ranking strategy is frequently adopted for competitions, as it means that if two (or more) competitors
8739 : !> tie for a position in the ranking, and the position of all those ranked below them is unaffected
8740 : !> (i.e., a competitor only comes second if exactly one person scores better than them,
8741 : !> third if exactly two people score better than them, fourth if exactly three people score better than them, etc.).<br>
8742 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number `1` (*first*),
8743 : !> *B* gets ranking number `2` (*joint second*), *C* also gets ranking number `2` (*joint second*) and *D* gets ranking number `4` (*fourth*).
8744 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Standard Competition ranking** `1224`.<br>
8745 : !>
8746 : !> \param[out] rank : The output `contiguous` array of rank `1` of type `integer` of default kind \IK
8747 : !> containing the ranks of the corresponding elements of `array`.<br>
8748 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
8749 : !> **Read `rank(i)` as the Standard rank of the `i`th element of `array`.**
8750 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
8751 : !> <ol>
8752 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
8753 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
8754 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
8755 : !> <li> type `integer` of kind \IKALL or,<br>
8756 : !> <li> type `logical` of kind \LKALL or,<br>
8757 : !> <li> type `complex` of kind \CKALL or,<br>
8758 : !> <li> type `real` of kind \RKALL,<br>
8759 : !> </ol>
8760 : !> or,
8761 : !> <ol>
8762 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
8763 : !> </ol>
8764 : !> whose elements rankings will be computed and returned.
8765 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type
8766 : !> and kind as the input `array`.<br>
8767 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
8768 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
8769 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
8770 : !> If `array` is a Fortran string (i.e., a scalar `character`),
8771 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
8772 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
8773 : !> \code{.F90}
8774 : !> function isSorted(a,b) result (sorted)
8775 : !> use pm_kind, only: SK, IK, LK, CK, RK
8776 : !> TYPE(KIND) , intent(in) :: a, b
8777 : !> logical(LK) :: sorted
8778 : !> end function
8779 : !> \endcode
8780 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
8781 : !> \code{.F90}
8782 : !> use pm_container, only: StrCon
8783 : !> use pm_kind, only: SK, IK, LK, CK, RK
8784 : !> character(*, SK), intent(in) :: a, b
8785 : !> integer(IK) , intent(in) :: a, b
8786 : !> logical(LK) , intent(in) :: a, b
8787 : !> complex(CK) , intent(in) :: a, b
8788 : !> real(RK) , intent(in) :: a, b
8789 : !> type(StrCon) , intent(in) :: a, b
8790 : !> \endcode
8791 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
8792 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
8793 : !> \code{.F90}
8794 : !> function isSorted(a,b) result (sorted)
8795 : !> character(1,SKC), intent(in) :: a, b
8796 : !> logical(LK) :: sorted
8797 : !> end function
8798 : !> \endcode
8799 : !> where `SKC` represents the kind of the input string argument `array`.<br>
8800 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
8801 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
8802 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
8803 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
8804 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
8805 : !>
8806 : !> \return
8807 : !> `rank(1:size(array)` : The output `contiguous` array of rank `1` of type `integer` of default kind \IK containing the ranks of the corresponding elements of `array`.<br>
8808 : !> The size of `rank` matches that of `array` (or its length type parameter if `array` is a scalar string).<br>
8809 : !> **Read `rank(i)` as the Standard rank of the `i`th element of `array`.**
8810 : !>
8811 : !> \interface{getRankStandard}
8812 : !> \code{.F90}
8813 : !>
8814 : !> use pm_arrayRank, only: getRankStandard
8815 : !>
8816 : !> rank(1:size(array)) = getRankStandard(array)
8817 : !> rank(1:size(array)) = getRankStandard(array, isSorted)
8818 : !>
8819 : !> \endcode
8820 : !>
8821 : !> \warning
8822 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
8823 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
8824 : !> identify ties within the Standard ranking of the input `array`.
8825 : !>
8826 : !> \warnpure
8827 : !>
8828 : !> \warning
8829 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
8830 : !>
8831 : !> \see
8832 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
8833 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
8834 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
8835 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
8836 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
8837 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
8838 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
8839 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
8840 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
8841 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
8842 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
8843 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
8844 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
8845 : !>
8846 : !> \example{getRankStandard}
8847 : !> \include{lineno} example/pm_arrayRank/getRankStandard/main.F90
8848 : !> \compilef{getRankStandard}
8849 : !> \output{getRankStandard}
8850 : !> \include{lineno} example/pm_arrayRank/getRankStandard/main.out.F90
8851 : !>
8852 : !> \test
8853 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
8854 : !>
8855 : !> \bug
8856 : !> \status \unresolved
8857 : !> \source \ifort{2021.5}
8858 : !> \desc
8859 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
8860 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
8861 : !> \remedy
8862 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
8863 : !>
8864 : !> \todo
8865 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
8866 : !>
8867 : !> \todo
8868 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
8869 : !>
8870 : !> \finmain{getRankStandard}
8871 : !>
8872 : !> \author
8873 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
8874 : interface getRankStandard
8875 :
8876 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8877 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8878 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8879 :
8880 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8881 :
8882 : #if SK5_ENABLED
8883 : module function getRankStandardDefCom_D0_SK5(array) result(rank)
8884 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8885 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D0_SK5
8886 : #endif
8887 : use pm_kind, only: TKR => IK, SKC => SK5
8888 : character(*,SKC) , intent(in) :: array
8889 : integer(TKR) :: rank(len(array, IK))
8890 : end function
8891 : #endif
8892 :
8893 : #if SK4_ENABLED
8894 : module function getRankStandardDefCom_D0_SK4(array) result(rank)
8895 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8896 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D0_SK4
8897 : #endif
8898 : use pm_kind, only: TKR => IK, SKC => SK4
8899 : character(*,SKC) , intent(in) :: array
8900 : integer(TKR) :: rank(len(array, IK))
8901 : end function
8902 : #endif
8903 :
8904 : #if SK3_ENABLED
8905 : module function getRankStandardDefCom_D0_SK3(array) result(rank)
8906 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8907 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D0_SK3
8908 : #endif
8909 : use pm_kind, only: TKR => IK, SKC => SK3
8910 : character(*,SKC) , intent(in) :: array
8911 : integer(TKR) :: rank(len(array, IK))
8912 : end function
8913 : #endif
8914 :
8915 : #if SK2_ENABLED
8916 : module function getRankStandardDefCom_D0_SK2(array) result(rank)
8917 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8918 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D0_SK2
8919 : #endif
8920 : use pm_kind, only: TKR => IK, SKC => SK2
8921 : character(*,SKC) , intent(in) :: array
8922 : integer(TKR) :: rank(len(array, IK))
8923 : end function
8924 : #endif
8925 :
8926 : #if SK1_ENABLED
8927 : module function getRankStandardDefCom_D0_SK1(array) result(rank)
8928 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8929 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D0_SK1
8930 : #endif
8931 : use pm_kind, only: TKR => IK, SKC => SK1
8932 : character(*,SKC) , intent(in) :: array
8933 : integer(TKR) :: rank(len(array, IK))
8934 : end function
8935 : #endif
8936 :
8937 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8938 :
8939 : #if SK5_ENABLED
8940 : module function getRankStandardDefCom_D1_SK5(array) result(rank)
8941 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8942 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_SK5
8943 : #endif
8944 : use pm_kind, only: TKR => IK, SKC => SK5
8945 : character(*,SKC) , intent(in) , contiguous :: array(:)
8946 : integer(TKR) :: rank(size(array, kind = IK))
8947 : end function
8948 : #endif
8949 :
8950 : #if SK4_ENABLED
8951 : module function getRankStandardDefCom_D1_SK4(array) result(rank)
8952 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8953 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_SK4
8954 : #endif
8955 : use pm_kind, only: TKR => IK, SKC => SK4
8956 : character(*,SKC) , intent(in) , contiguous :: array(:)
8957 : integer(TKR) :: rank(size(array, kind = IK))
8958 : end function
8959 : #endif
8960 :
8961 : #if SK3_ENABLED
8962 : module function getRankStandardDefCom_D1_SK3(array) result(rank)
8963 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8964 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_SK3
8965 : #endif
8966 : use pm_kind, only: TKR => IK, SKC => SK3
8967 : character(*,SKC) , intent(in) , contiguous :: array(:)
8968 : integer(TKR) :: rank(size(array, kind = IK))
8969 : end function
8970 : #endif
8971 :
8972 : #if SK2_ENABLED
8973 : module function getRankStandardDefCom_D1_SK2(array) result(rank)
8974 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8975 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_SK2
8976 : #endif
8977 : use pm_kind, only: TKR => IK, SKC => SK2
8978 : character(*,SKC) , intent(in) , contiguous :: array(:)
8979 : integer(TKR) :: rank(size(array, kind = IK))
8980 : end function
8981 : #endif
8982 :
8983 : #if SK1_ENABLED
8984 : module function getRankStandardDefCom_D1_SK1(array) result(rank)
8985 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8986 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_SK1
8987 : #endif
8988 : use pm_kind, only: TKR => IK, SKC => SK1
8989 : character(*,SKC) , intent(in) , contiguous :: array(:)
8990 : integer(TKR) :: rank(size(array, kind = IK))
8991 : end function
8992 : #endif
8993 :
8994 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
8995 :
8996 : #if IK5_ENABLED
8997 : module function getRankStandardDefCom_D1_IK5(array) result(rank)
8998 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
8999 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_IK5
9000 : #endif
9001 : use pm_kind, only: TKR => IK, IKC => IK5
9002 : integer(IKC) , intent(in) , contiguous :: array(:)
9003 : integer(TKR) :: rank(size(array, kind = IK))
9004 : end function
9005 : #endif
9006 :
9007 : #if IK4_ENABLED
9008 : module function getRankStandardDefCom_D1_IK4(array) result(rank)
9009 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9010 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_IK4
9011 : #endif
9012 : use pm_kind, only: TKR => IK, IKC => IK4
9013 : integer(IKC) , intent(in) , contiguous :: array(:)
9014 : integer(TKR) :: rank(size(array, kind = IK))
9015 : end function
9016 : #endif
9017 :
9018 : #if IK3_ENABLED
9019 : module function getRankStandardDefCom_D1_IK3(array) result(rank)
9020 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9021 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_IK3
9022 : #endif
9023 : use pm_kind, only: TKR => IK, IKC => IK3
9024 : integer(IKC) , intent(in) , contiguous :: array(:)
9025 : integer(TKR) :: rank(size(array, kind = IK))
9026 : end function
9027 : #endif
9028 :
9029 : #if IK2_ENABLED
9030 : module function getRankStandardDefCom_D1_IK2(array) result(rank)
9031 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9032 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_IK2
9033 : #endif
9034 : use pm_kind, only: TKR => IK, IKC => IK2
9035 : integer(IKC) , intent(in) , contiguous :: array(:)
9036 : integer(TKR) :: rank(size(array, kind = IK))
9037 : end function
9038 : #endif
9039 :
9040 : #if IK1_ENABLED
9041 : module function getRankStandardDefCom_D1_IK1(array) result(rank)
9042 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9043 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_IK1
9044 : #endif
9045 : use pm_kind, only: TKR => IK, IKC => IK1
9046 : integer(IKC) , intent(in) , contiguous :: array(:)
9047 : integer(TKR) :: rank(size(array, kind = IK))
9048 : end function
9049 : #endif
9050 :
9051 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9052 :
9053 : #if LK5_ENABLED
9054 : module function getRankStandardDefCom_D1_LK5(array) result(rank)
9055 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9056 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_LK5
9057 : #endif
9058 : use pm_kind, only: TKR => IK, LKC => LK5
9059 : logical(LKC) , intent(in) , contiguous :: array(:)
9060 : integer(TKR) :: rank(size(array, kind = IK))
9061 : end function
9062 : #endif
9063 :
9064 : #if LK4_ENABLED
9065 : module function getRankStandardDefCom_D1_LK4(array) result(rank)
9066 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9067 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_LK4
9068 : #endif
9069 : use pm_kind, only: TKR => IK, LKC => LK4
9070 : logical(LKC) , intent(in) , contiguous :: array(:)
9071 : integer(TKR) :: rank(size(array, kind = IK))
9072 : end function
9073 : #endif
9074 :
9075 : #if LK3_ENABLED
9076 : module function getRankStandardDefCom_D1_LK3(array) result(rank)
9077 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9078 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_LK3
9079 : #endif
9080 : use pm_kind, only: TKR => IK, LKC => LK3
9081 : logical(LKC) , intent(in) , contiguous :: array(:)
9082 : integer(TKR) :: rank(size(array, kind = IK))
9083 : end function
9084 : #endif
9085 :
9086 : #if LK2_ENABLED
9087 : module function getRankStandardDefCom_D1_LK2(array) result(rank)
9088 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9089 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_LK2
9090 : #endif
9091 : use pm_kind, only: TKR => IK, LKC => LK2
9092 : logical(LKC) , intent(in) , contiguous :: array(:)
9093 : integer(TKR) :: rank(size(array, kind = IK))
9094 : end function
9095 : #endif
9096 :
9097 : #if LK1_ENABLED
9098 : module function getRankStandardDefCom_D1_LK1(array) result(rank)
9099 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9100 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_LK1
9101 : #endif
9102 : use pm_kind, only: TKR => IK, LKC => LK1
9103 : logical(LKC) , intent(in) , contiguous :: array(:)
9104 : integer(TKR) :: rank(size(array, kind = IK))
9105 : end function
9106 : #endif
9107 :
9108 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9109 :
9110 : #if CK5_ENABLED
9111 : module function getRankStandardDefCom_D1_CK5(array) result(rank)
9112 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9113 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_CK5
9114 : #endif
9115 : use pm_kind, only: TKR => IK, CKC => CK5
9116 : complex(CKC) , intent(in) , contiguous :: array(:)
9117 : integer(TKR) :: rank(size(array, kind = IK))
9118 : end function
9119 : #endif
9120 :
9121 : #if CK4_ENABLED
9122 : module function getRankStandardDefCom_D1_CK4(array) result(rank)
9123 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9124 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_CK4
9125 : #endif
9126 : use pm_kind, only: TKR => IK, CKC => CK4
9127 : complex(CKC) , intent(in) , contiguous :: array(:)
9128 : integer(TKR) :: rank(size(array, kind = IK))
9129 : end function
9130 : #endif
9131 :
9132 : #if CK3_ENABLED
9133 : module function getRankStandardDefCom_D1_CK3(array) result(rank)
9134 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9135 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_CK3
9136 : #endif
9137 : use pm_kind, only: TKR => IK, CKC => CK3
9138 : complex(CKC) , intent(in) , contiguous :: array(:)
9139 : integer(TKR) :: rank(size(array, kind = IK))
9140 : end function
9141 : #endif
9142 :
9143 : #if CK2_ENABLED
9144 : module function getRankStandardDefCom_D1_CK2(array) result(rank)
9145 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9146 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_CK2
9147 : #endif
9148 : use pm_kind, only: TKR => IK, CKC => CK2
9149 : complex(CKC) , intent(in) , contiguous :: array(:)
9150 : integer(TKR) :: rank(size(array, kind = IK))
9151 : end function
9152 : #endif
9153 :
9154 : #if CK1_ENABLED
9155 : module function getRankStandardDefCom_D1_CK1(array) result(rank)
9156 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9157 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_CK1
9158 : #endif
9159 : use pm_kind, only: TKR => IK, CKC => CK1
9160 : complex(CKC) , intent(in) , contiguous :: array(:)
9161 : integer(TKR) :: rank(size(array, kind = IK))
9162 : end function
9163 : #endif
9164 :
9165 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9166 :
9167 : #if RK5_ENABLED
9168 : module function getRankStandardDefCom_D1_RK5(array) result(rank)
9169 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9170 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_RK5
9171 : #endif
9172 : use pm_kind, only: TKR => IK, RKC => RK5
9173 : real(RKC) , intent(in) , contiguous :: array(:)
9174 : integer(TKR) :: rank(size(array, kind = IK))
9175 : end function
9176 : #endif
9177 :
9178 : #if RK4_ENABLED
9179 : module function getRankStandardDefCom_D1_RK4(array) result(rank)
9180 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9181 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_RK4
9182 : #endif
9183 : use pm_kind, only: TKR => IK, RKC => RK4
9184 : real(RKC) , intent(in) , contiguous :: array(:)
9185 : integer(TKR) :: rank(size(array, kind = IK))
9186 : end function
9187 : #endif
9188 :
9189 : #if RK3_ENABLED
9190 : module function getRankStandardDefCom_D1_RK3(array) result(rank)
9191 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9192 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_RK3
9193 : #endif
9194 : use pm_kind, only: TKR => IK, RKC => RK3
9195 : real(RKC) , intent(in) , contiguous :: array(:)
9196 : integer(TKR) :: rank(size(array, kind = IK))
9197 : end function
9198 : #endif
9199 :
9200 : #if RK2_ENABLED
9201 : module function getRankStandardDefCom_D1_RK2(array) result(rank)
9202 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9203 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_RK2
9204 : #endif
9205 : use pm_kind, only: TKR => IK, RKC => RK2
9206 : real(RKC) , intent(in) , contiguous :: array(:)
9207 : integer(TKR) :: rank(size(array, kind = IK))
9208 : end function
9209 : #endif
9210 :
9211 : #if RK1_ENABLED
9212 : module function getRankStandardDefCom_D1_RK1(array) result(rank)
9213 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9214 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_RK1
9215 : #endif
9216 : use pm_kind, only: TKR => IK, RKC => RK1
9217 : real(RKC) , intent(in) , contiguous :: array(:)
9218 : integer(TKR) :: rank(size(array, kind = IK))
9219 : end function
9220 : #endif
9221 :
9222 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9223 :
9224 : #if SK5_ENABLED
9225 : module function getRankStandardDefCom_D1_PSSK5(array) result(rank)
9226 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9227 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_PSSK5
9228 : #endif
9229 : use pm_kind, only: TKR => IK, SKC => SK5
9230 : use pm_container, only: css_pdt
9231 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9232 : integer(TKR) :: rank(size(array, kind = IK))
9233 : end function
9234 : #endif
9235 :
9236 : #if SK4_ENABLED
9237 : module function getRankStandardDefCom_D1_PSSK4(array) result(rank)
9238 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9239 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_PSSK4
9240 : #endif
9241 : use pm_kind, only: TKR => IK, SKC => SK4
9242 : use pm_container, only: css_pdt
9243 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9244 : integer(TKR) :: rank(size(array, kind = IK))
9245 : end function
9246 : #endif
9247 :
9248 : #if SK3_ENABLED
9249 : module function getRankStandardDefCom_D1_PSSK3(array) result(rank)
9250 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9251 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_PSSK3
9252 : #endif
9253 : use pm_kind, only: TKR => IK, SKC => SK3
9254 : use pm_container, only: css_pdt
9255 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9256 : integer(TKR) :: rank(size(array, kind = IK))
9257 : end function
9258 : #endif
9259 :
9260 : #if SK2_ENABLED
9261 : module function getRankStandardDefCom_D1_PSSK2(array) result(rank)
9262 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9263 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_PSSK2
9264 : #endif
9265 : use pm_kind, only: TKR => IK, SKC => SK2
9266 : use pm_container, only: css_pdt
9267 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9268 : integer(TKR) :: rank(size(array, kind = IK))
9269 : end function
9270 : #endif
9271 :
9272 : #if SK1_ENABLED
9273 : module function getRankStandardDefCom_D1_PSSK1(array) result(rank)
9274 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9275 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_PSSK1
9276 : #endif
9277 : use pm_kind, only: TKR => IK, SKC => SK1
9278 : use pm_container, only: css_pdt
9279 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9280 : integer(TKR) :: rank(size(array, kind = IK))
9281 : end function
9282 : #endif
9283 :
9284 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9285 :
9286 : module function getRankStandardDefCom_D1_BSSK(array) result(rank)
9287 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9288 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardDefCom_D1_BSSK
9289 : #endif
9290 : use pm_kind, only: TKR => IK, SKC => SK
9291 : use pm_container, only: css_type
9292 : type(css_type) , intent(in) , contiguous :: array(:)
9293 : integer(TKR) :: rank(size(array, kind = IK))
9294 : end function
9295 :
9296 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9297 :
9298 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9299 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9300 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9301 :
9302 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9303 :
9304 : #if SK5_ENABLED
9305 : module function getRankStandardCusCom_D0_SK5(array, isSorted) result(rank)
9306 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9307 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D0_SK5
9308 : #endif
9309 : use pm_kind, only: TKR => IK, SKC => SK5
9310 : character(*,SKC) , intent(in) :: array
9311 : procedure(logical(LK)) :: isSorted
9312 : integer(TKR) :: rank(len(array, IK))
9313 : end function
9314 : #endif
9315 :
9316 : #if SK4_ENABLED
9317 : module function getRankStandardCusCom_D0_SK4(array, isSorted) result(rank)
9318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9319 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D0_SK4
9320 : #endif
9321 : use pm_kind, only: TKR => IK, SKC => SK4
9322 : character(*,SKC) , intent(in) :: array
9323 : procedure(logical(LK)) :: isSorted
9324 : integer(TKR) :: rank(len(array, IK))
9325 : end function
9326 : #endif
9327 :
9328 : #if SK3_ENABLED
9329 : module function getRankStandardCusCom_D0_SK3(array, isSorted) result(rank)
9330 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9331 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D0_SK3
9332 : #endif
9333 : use pm_kind, only: TKR => IK, SKC => SK3
9334 : character(*,SKC) , intent(in) :: array
9335 : procedure(logical(LK)) :: isSorted
9336 : integer(TKR) :: rank(len(array, IK))
9337 : end function
9338 : #endif
9339 :
9340 : #if SK2_ENABLED
9341 : module function getRankStandardCusCom_D0_SK2(array, isSorted) result(rank)
9342 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9343 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D0_SK2
9344 : #endif
9345 : use pm_kind, only: TKR => IK, SKC => SK2
9346 : character(*,SKC) , intent(in) :: array
9347 : procedure(logical(LK)) :: isSorted
9348 : integer(TKR) :: rank(len(array, IK))
9349 : end function
9350 : #endif
9351 :
9352 : #if SK1_ENABLED
9353 : module function getRankStandardCusCom_D0_SK1(array, isSorted) result(rank)
9354 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9355 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D0_SK1
9356 : #endif
9357 : use pm_kind, only: TKR => IK, SKC => SK1
9358 : character(*,SKC) , intent(in) :: array
9359 : procedure(logical(LK)) :: isSorted
9360 : integer(TKR) :: rank(len(array, IK))
9361 : end function
9362 : #endif
9363 :
9364 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9365 :
9366 : #if SK5_ENABLED
9367 : module function getRankStandardCusCom_D1_SK5(array, isSorted) result(rank)
9368 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9369 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_SK5
9370 : #endif
9371 : use pm_kind, only: TKR => IK, SKC => SK5
9372 : character(*,SKC) , intent(in) , contiguous :: array(:)
9373 : procedure(logical(LK)) :: isSorted
9374 : integer(TKR) :: rank(size(array, kind = IK))
9375 : end function
9376 : #endif
9377 :
9378 : #if SK4_ENABLED
9379 : module function getRankStandardCusCom_D1_SK4(array, isSorted) result(rank)
9380 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9381 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_SK4
9382 : #endif
9383 : use pm_kind, only: TKR => IK, SKC => SK4
9384 : character(*,SKC) , intent(in) , contiguous :: array(:)
9385 : procedure(logical(LK)) :: isSorted
9386 : integer(TKR) :: rank(size(array, kind = IK))
9387 : end function
9388 : #endif
9389 :
9390 : #if SK3_ENABLED
9391 : module function getRankStandardCusCom_D1_SK3(array, isSorted) result(rank)
9392 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9393 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_SK3
9394 : #endif
9395 : use pm_kind, only: TKR => IK, SKC => SK3
9396 : character(*,SKC) , intent(in) , contiguous :: array(:)
9397 : procedure(logical(LK)) :: isSorted
9398 : integer(TKR) :: rank(size(array, kind = IK))
9399 : end function
9400 : #endif
9401 :
9402 : #if SK2_ENABLED
9403 : module function getRankStandardCusCom_D1_SK2(array, isSorted) result(rank)
9404 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9405 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_SK2
9406 : #endif
9407 : use pm_kind, only: TKR => IK, SKC => SK2
9408 : character(*,SKC) , intent(in) , contiguous :: array(:)
9409 : procedure(logical(LK)) :: isSorted
9410 : integer(TKR) :: rank(size(array, kind = IK))
9411 : end function
9412 : #endif
9413 :
9414 : #if SK1_ENABLED
9415 : module function getRankStandardCusCom_D1_SK1(array, isSorted) result(rank)
9416 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9417 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_SK1
9418 : #endif
9419 : use pm_kind, only: TKR => IK, SKC => SK1
9420 : character(*,SKC) , intent(in) , contiguous :: array(:)
9421 : procedure(logical(LK)) :: isSorted
9422 : integer(TKR) :: rank(size(array, kind = IK))
9423 : end function
9424 : #endif
9425 :
9426 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9427 :
9428 : #if IK5_ENABLED
9429 : module function getRankStandardCusCom_D1_IK5(array, isSorted) result(rank)
9430 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9431 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_IK5
9432 : #endif
9433 : use pm_kind, only: TKR => IK, IKC => IK5
9434 : integer(IKC) , intent(in) , contiguous :: array(:)
9435 : procedure(logical(LK)) :: isSorted
9436 : integer(TKR) :: rank(size(array, kind = IK))
9437 : end function
9438 : #endif
9439 :
9440 : #if IK4_ENABLED
9441 : module function getRankStandardCusCom_D1_IK4(array, isSorted) result(rank)
9442 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9443 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_IK4
9444 : #endif
9445 : use pm_kind, only: TKR => IK, IKC => IK4
9446 : integer(IKC) , intent(in) , contiguous :: array(:)
9447 : procedure(logical(LK)) :: isSorted
9448 : integer(TKR) :: rank(size(array, kind = IK))
9449 : end function
9450 : #endif
9451 :
9452 : #if IK3_ENABLED
9453 : module function getRankStandardCusCom_D1_IK3(array, isSorted) result(rank)
9454 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9455 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_IK3
9456 : #endif
9457 : use pm_kind, only: TKR => IK, IKC => IK3
9458 : integer(IKC) , intent(in) , contiguous :: array(:)
9459 : procedure(logical(LK)) :: isSorted
9460 : integer(TKR) :: rank(size(array, kind = IK))
9461 : end function
9462 : #endif
9463 :
9464 : #if IK2_ENABLED
9465 : module function getRankStandardCusCom_D1_IK2(array, isSorted) result(rank)
9466 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9467 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_IK2
9468 : #endif
9469 : use pm_kind, only: TKR => IK, IKC => IK2
9470 : integer(IKC) , intent(in) , contiguous :: array(:)
9471 : procedure(logical(LK)) :: isSorted
9472 : integer(TKR) :: rank(size(array, kind = IK))
9473 : end function
9474 : #endif
9475 :
9476 : #if IK1_ENABLED
9477 : module function getRankStandardCusCom_D1_IK1(array, isSorted) result(rank)
9478 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9479 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_IK1
9480 : #endif
9481 : use pm_kind, only: TKR => IK, IKC => IK1
9482 : integer(IKC) , intent(in) , contiguous :: array(:)
9483 : procedure(logical(LK)) :: isSorted
9484 : integer(TKR) :: rank(size(array, kind = IK))
9485 : end function
9486 : #endif
9487 :
9488 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9489 :
9490 : #if LK5_ENABLED
9491 : module function getRankStandardCusCom_D1_LK5(array, isSorted) result(rank)
9492 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9493 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_LK5
9494 : #endif
9495 : use pm_kind, only: TKR => IK, LKC => LK5
9496 : logical(LKC) , intent(in) , contiguous :: array(:)
9497 : procedure(logical(LK)) :: isSorted
9498 : integer(TKR) :: rank(size(array, kind = IK))
9499 : end function
9500 : #endif
9501 :
9502 : #if LK4_ENABLED
9503 : module function getRankStandardCusCom_D1_LK4(array, isSorted) result(rank)
9504 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9505 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_LK4
9506 : #endif
9507 : use pm_kind, only: TKR => IK, LKC => LK4
9508 : logical(LKC) , intent(in) , contiguous :: array(:)
9509 : procedure(logical(LK)) :: isSorted
9510 : integer(TKR) :: rank(size(array, kind = IK))
9511 : end function
9512 : #endif
9513 :
9514 : #if LK3_ENABLED
9515 : module function getRankStandardCusCom_D1_LK3(array, isSorted) result(rank)
9516 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9517 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_LK3
9518 : #endif
9519 : use pm_kind, only: TKR => IK, LKC => LK3
9520 : logical(LKC) , intent(in) , contiguous :: array(:)
9521 : procedure(logical(LK)) :: isSorted
9522 : integer(TKR) :: rank(size(array, kind = IK))
9523 : end function
9524 : #endif
9525 :
9526 : #if LK2_ENABLED
9527 : module function getRankStandardCusCom_D1_LK2(array, isSorted) result(rank)
9528 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9529 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_LK2
9530 : #endif
9531 : use pm_kind, only: TKR => IK, LKC => LK2
9532 : logical(LKC) , intent(in) , contiguous :: array(:)
9533 : procedure(logical(LK)) :: isSorted
9534 : integer(TKR) :: rank(size(array, kind = IK))
9535 : end function
9536 : #endif
9537 :
9538 : #if LK1_ENABLED
9539 : module function getRankStandardCusCom_D1_LK1(array, isSorted) result(rank)
9540 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9541 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_LK1
9542 : #endif
9543 : use pm_kind, only: TKR => IK, LKC => LK1
9544 : logical(LKC) , intent(in) , contiguous :: array(:)
9545 : procedure(logical(LK)) :: isSorted
9546 : integer(TKR) :: rank(size(array, kind = IK))
9547 : end function
9548 : #endif
9549 :
9550 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9551 :
9552 : #if CK5_ENABLED
9553 : module function getRankStandardCusCom_D1_CK5(array, isSorted) result(rank)
9554 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9555 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_CK5
9556 : #endif
9557 : use pm_kind, only: TKR => IK, CKC => CK5
9558 : complex(CKC) , intent(in) , contiguous :: array(:)
9559 : procedure(logical(LK)) :: isSorted
9560 : integer(TKR) :: rank(size(array, kind = IK))
9561 : end function
9562 : #endif
9563 :
9564 : #if CK4_ENABLED
9565 : module function getRankStandardCusCom_D1_CK4(array, isSorted) result(rank)
9566 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9567 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_CK4
9568 : #endif
9569 : use pm_kind, only: TKR => IK, CKC => CK4
9570 : complex(CKC) , intent(in) , contiguous :: array(:)
9571 : procedure(logical(LK)) :: isSorted
9572 : integer(TKR) :: rank(size(array, kind = IK))
9573 : end function
9574 : #endif
9575 :
9576 : #if CK3_ENABLED
9577 : module function getRankStandardCusCom_D1_CK3(array, isSorted) result(rank)
9578 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9579 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_CK3
9580 : #endif
9581 : use pm_kind, only: TKR => IK, CKC => CK3
9582 : complex(CKC) , intent(in) , contiguous :: array(:)
9583 : procedure(logical(LK)) :: isSorted
9584 : integer(TKR) :: rank(size(array, kind = IK))
9585 : end function
9586 : #endif
9587 :
9588 : #if CK2_ENABLED
9589 : module function getRankStandardCusCom_D1_CK2(array, isSorted) result(rank)
9590 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9591 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_CK2
9592 : #endif
9593 : use pm_kind, only: TKR => IK, CKC => CK2
9594 : complex(CKC) , intent(in) , contiguous :: array(:)
9595 : procedure(logical(LK)) :: isSorted
9596 : integer(TKR) :: rank(size(array, kind = IK))
9597 : end function
9598 : #endif
9599 :
9600 : #if CK1_ENABLED
9601 : module function getRankStandardCusCom_D1_CK1(array, isSorted) result(rank)
9602 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9603 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_CK1
9604 : #endif
9605 : use pm_kind, only: TKR => IK, CKC => CK1
9606 : complex(CKC) , intent(in) , contiguous :: array(:)
9607 : procedure(logical(LK)) :: isSorted
9608 : integer(TKR) :: rank(size(array, kind = IK))
9609 : end function
9610 : #endif
9611 :
9612 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9613 :
9614 : #if RK5_ENABLED
9615 : module function getRankStandardCusCom_D1_RK5(array, isSorted) result(rank)
9616 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9617 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_RK5
9618 : #endif
9619 : use pm_kind, only: TKR => IK, RKC => RK5
9620 : real(RKC) , intent(in) , contiguous :: array(:)
9621 : procedure(logical(LK)) :: isSorted
9622 : integer(TKR) :: rank(size(array, kind = IK))
9623 : end function
9624 : #endif
9625 :
9626 : #if RK4_ENABLED
9627 : module function getRankStandardCusCom_D1_RK4(array, isSorted) result(rank)
9628 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9629 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_RK4
9630 : #endif
9631 : use pm_kind, only: TKR => IK, RKC => RK4
9632 : real(RKC) , intent(in) , contiguous :: array(:)
9633 : procedure(logical(LK)) :: isSorted
9634 : integer(TKR) :: rank(size(array, kind = IK))
9635 : end function
9636 : #endif
9637 :
9638 : #if RK3_ENABLED
9639 : module function getRankStandardCusCom_D1_RK3(array, isSorted) result(rank)
9640 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9641 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_RK3
9642 : #endif
9643 : use pm_kind, only: TKR => IK, RKC => RK3
9644 : real(RKC) , intent(in) , contiguous :: array(:)
9645 : procedure(logical(LK)) :: isSorted
9646 : integer(TKR) :: rank(size(array, kind = IK))
9647 : end function
9648 : #endif
9649 :
9650 : #if RK2_ENABLED
9651 : module function getRankStandardCusCom_D1_RK2(array, isSorted) result(rank)
9652 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9653 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_RK2
9654 : #endif
9655 : use pm_kind, only: TKR => IK, RKC => RK2
9656 : real(RKC) , intent(in) , contiguous :: array(:)
9657 : procedure(logical(LK)) :: isSorted
9658 : integer(TKR) :: rank(size(array, kind = IK))
9659 : end function
9660 : #endif
9661 :
9662 : #if RK1_ENABLED
9663 : module function getRankStandardCusCom_D1_RK1(array, isSorted) result(rank)
9664 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9665 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_RK1
9666 : #endif
9667 : use pm_kind, only: TKR => IK, RKC => RK1
9668 : real(RKC) , intent(in) , contiguous :: array(:)
9669 : procedure(logical(LK)) :: isSorted
9670 : integer(TKR) :: rank(size(array, kind = IK))
9671 : end function
9672 : #endif
9673 :
9674 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9675 :
9676 : #if SK5_ENABLED
9677 : module function getRankStandardCusCom_D1_PSSK5(array, isSorted) result(rank)
9678 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9679 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_PSSK5
9680 : #endif
9681 : use pm_kind, only: TKR => IK, SKC => SK5
9682 : use pm_container, only: css_pdt
9683 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9684 : procedure(logical(LK)) :: isSorted
9685 : integer(TKR) :: rank(size(array, kind = IK))
9686 : end function
9687 : #endif
9688 :
9689 : #if SK4_ENABLED
9690 : module function getRankStandardCusCom_D1_PSSK4(array, isSorted) result(rank)
9691 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9692 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_PSSK4
9693 : #endif
9694 : use pm_kind, only: TKR => IK, SKC => SK4
9695 : use pm_container, only: css_pdt
9696 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9697 : procedure(logical(LK)) :: isSorted
9698 : integer(TKR) :: rank(size(array, kind = IK))
9699 : end function
9700 : #endif
9701 :
9702 : #if SK3_ENABLED
9703 : module function getRankStandardCusCom_D1_PSSK3(array, isSorted) result(rank)
9704 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9705 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_PSSK3
9706 : #endif
9707 : use pm_kind, only: TKR => IK, SKC => SK3
9708 : use pm_container, only: css_pdt
9709 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9710 : procedure(logical(LK)) :: isSorted
9711 : integer(TKR) :: rank(size(array, kind = IK))
9712 : end function
9713 : #endif
9714 :
9715 : #if SK2_ENABLED
9716 : module function getRankStandardCusCom_D1_PSSK2(array, isSorted) result(rank)
9717 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9718 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_PSSK2
9719 : #endif
9720 : use pm_kind, only: TKR => IK, SKC => SK2
9721 : use pm_container, only: css_pdt
9722 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9723 : procedure(logical(LK)) :: isSorted
9724 : integer(TKR) :: rank(size(array, kind = IK))
9725 : end function
9726 : #endif
9727 :
9728 : #if SK1_ENABLED
9729 : module function getRankStandardCusCom_D1_PSSK1(array, isSorted) result(rank)
9730 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9731 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_PSSK1
9732 : #endif
9733 : use pm_kind, only: TKR => IK, SKC => SK1
9734 : use pm_container, only: css_pdt
9735 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
9736 : integer(TKR) :: rank(size(array, kind = IK))
9737 : procedure(logical(LK)) :: isSorted
9738 : end function
9739 : #endif
9740 :
9741 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9742 :
9743 : module function getRankStandardCusCom_D1_BSSK(array, isSorted) result(rank)
9744 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9745 : !DEC$ ATTRIBUTES DLLEXPORT :: getRankStandardCusCom_D1_BSSK
9746 : #endif
9747 : use pm_kind, only: TKR => IK, SKC => SK
9748 : use pm_container, only: css_type
9749 : type(css_type) , intent(in) , contiguous :: array(:)
9750 : procedure(logical(LK)) :: isSorted
9751 : integer(TKR) :: rank(size(array, kind = IK))
9752 : end function
9753 :
9754 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9755 :
9756 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9757 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9758 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9759 :
9760 : end interface
9761 :
9762 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9763 :
9764 : !> \brief
9765 : !> Return the **Standard rank** of the input scalar string or `contiguous` `array` of rank `1` in **ascending order**
9766 : !> or in the order specified by the input procedure `isSorted()` using the Quicksort algorithm such that `array(rank)`
9767 : !> will be in ascending order (or in the requested order as specified by `isSorted()`.
9768 : !>
9769 : !> \details
9770 : !> This kind of ranking of values is widely known as <b>Standard Competition (`1224`) ranking</b>.<br>
9771 : !> In Standard Competition ranking, items that compare equal receive the same ranking number,
9772 : !> and then a gap is left in the ranking numbers. The number of ranking numbers that are left out
9773 : !> in this gap is one less than the number of items that compared equal.<br>
9774 : !> Equivalently, the ranking number of each item is `1` plus the number of items ranked above it.<br>
9775 : !> This ranking strategy is frequently adopted for competitions, as it means that if two (or more) competitors
9776 : !> tie for a position in the ranking, and the position of all those ranked below them is unaffected
9777 : !> (i.e., a competitor only comes second if exactly one person scores better than them,
9778 : !> third if exactly two people score better than them, fourth if exactly three people score better than them, etc.).<br>
9779 : !> Thus if *A* ranks ahead of *B* and *C* (which compare equal) which are both ranked ahead of *D*, then *A* gets ranking number `1` (*first*),
9780 : !> *B* gets ranking number `2` (*joint second*), *C* also gets ranking number `2` (*joint second*) and *D* gets ranking number `4` (*fourth*).
9781 : !> That is, if `A < B == C < D`, then the sequence `ABCD` has the **Standard Competition ranking** `1224`.<br>
9782 : !>
9783 : !> \param[in] array : The input `contiguous` array of rank `1` of either<br>
9784 : !> <ol>
9785 : !> <li> type [css_pdt](@ref pm_container::css_pdt) (parameterized container of string of kind \SKALL) or,<br>
9786 : !> <li> type [css_type](@ref pm_container::css_type) (container of string of default kind \SK) or,<br>
9787 : !> <li> type `character` of kind \SKALL of arbitrary length type parameter or,
9788 : !> <li> type `integer` of kind \IKALL or,<br>
9789 : !> <li> type `logical` of kind \LKALL or,<br>
9790 : !> <li> type `complex` of kind \CKALL or,<br>
9791 : !> <li> type `real` of kind \RKALL,<br>
9792 : !> </ol>
9793 : !> or,
9794 : !> <ol>
9795 : !> <li> a **scalar** of type `character` of kind \SKALL of arbitrary length type parameter,<br>
9796 : !> </ol>
9797 : !> whose elements rankings will be computed and returned.
9798 : !> \param[out] rank : The output `contiguous` array of rank `1` of type `integer` of default kind \IK
9799 : !> containing the ranks of the corresponding elements of `array`.<br>
9800 : !> The size of `rank` must match that of `array` (or its length type parameter if `array` is a scalar string).<br>
9801 : !> **Read `rank(i)` as the Standard rank of the `i`th element of `array`.**
9802 : !> \param isSorted : The `external` user-specified function that takes two input **scalar** arguments of the same type
9803 : !> and kind as the input `array`.<br>
9804 : !> It returns a scalar `logical` of default kind \LK that is `.true.` if the first
9805 : !> input scalar argument is sorted with respect to the second input argument according to the user-defined sorting condition
9806 : !> within `isSorted()`, otherwise, it is `.false.`.<br>
9807 : !> If `array` is a Fortran string (i.e., a scalar `character`),
9808 : !> then both input arguments to `isSorted()` are single `character(1,SKC)` where `SKC` is the kind of `array`.<br>
9809 : !> The following illustrates the generic interface of `isSorted()` when the rank of the input `array` is `1`,
9810 : !> \code{.F90}
9811 : !> function isSorted(a,b) result (sorted)
9812 : !> use pm_kind, only: SK, IK, LK, CK, RK
9813 : !> TYPE(KIND) , intent(in) :: a, b
9814 : !> logical(LK) :: sorted
9815 : !> end function
9816 : !> \endcode
9817 : !> where `TYPE(KIND)` represents the type and kind of the input argument `array`, which can be one of the following,
9818 : !> \code{.F90}
9819 : !> use pm_container, only: StrCon
9820 : !> use pm_kind, only: SK, IK, LK, CK, RK
9821 : !> character(*, SK), intent(in) :: a, b
9822 : !> integer(IK) , intent(in) :: a, b
9823 : !> logical(LK) , intent(in) :: a, b
9824 : !> complex(CK) , intent(in) :: a, b
9825 : !> real(RK) , intent(in) :: a, b
9826 : !> type(StrCon) , intent(in) :: a, b
9827 : !> \endcode
9828 : !> where the kinds `SK`, `IK`, `LK`, `CK`, `RK`, can refer to any kind type parameter that is supported by the processor.<br>
9829 : !> The following illustrates the generic interface of `isSorted()` when the input `array` is a scalar string,
9830 : !> \code{.F90}
9831 : !> function isSorted(a,b) result (sorted)
9832 : !> character(1,SKC), intent(in) :: a, b
9833 : !> logical(LK) :: sorted
9834 : !> end function
9835 : !> \endcode
9836 : !> where `SKC` represents the kind of the input string argument `array`.<br>
9837 : !> This user-defined equivalence check is extremely useful where a user-defined sorting criterion other than simple ascending order
9838 : !> is needed, for example, when the case-sensitivity of an input string or array of strings is irrelevant or when sorting of
9839 : !> the absolute values matters excluding the signs of the numbers, or when descending order is desired.<br>
9840 : !> In such cases, user can define a custom sorting condition within the user-defined external function `isSorted` to achieve the goal.<br>
9841 : !> (**optional**, the default sorting condition is ascending order, that is `a < b`.)
9842 : !>
9843 : !> \interface{setRankStandard}
9844 : !> \code{.F90}
9845 : !>
9846 : !> use pm_arrayRank, only: setRankStandard
9847 : !>
9848 : !> call setRankStandard(rank, array)
9849 : !> call setRankStandard(rank, array, isSorted)
9850 : !>
9851 : !> \endcode
9852 : !>
9853 : !> \warning
9854 : !> Note that the definition of `isSorted()`, if present, must be such that `isSorted() .and. .not. isSorted()`
9855 : !> is equivalent to an equality check for two elements of the input `array`. This equality check is used to
9856 : !> identify ties within the Standard ranking of the input `array`.
9857 : !>
9858 : !> \warnpure
9859 : !>
9860 : !> \warning
9861 : !> The procedures under this generic interface are always `impure` when the input argument `isSorted` is present.
9862 : !>
9863 : !> \see
9864 : !> [setSelected](@ref pm_arraySelect::setSelected)<br>
9865 : !> [getRankDense](@ref pm_arrayRank::getRankDense)<br>
9866 : !> [setRankDense](@ref pm_arrayRank::setRankDense)<br>
9867 : !> [getRankOrdinal](@ref pm_arrayRank::getRankOrdinal)<br>
9868 : !> [setRankOrdinal](@ref pm_arrayRank::setRankOrdinal)<br>
9869 : !> [getRankFractional](@ref pm_arrayRank::getRankFractional)<br>
9870 : !> [setRankFractional](@ref pm_arrayRank::setRankFractional)<br>
9871 : !> [getRankStandard](@ref pm_arrayRank::getRankStandard)<br>
9872 : !> [setRankStandard](@ref pm_arrayRank::setRankStandard)<br>
9873 : !> [getRankModified](@ref pm_arrayRank::getRankModified)<br>
9874 : !> [setRankModified](@ref pm_arrayRank::setRankModified)<br>
9875 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
9876 : !> [setSorted](@ref pm_arraySort::setSorted)<br>
9877 : !>
9878 : !> \example{setRankStandard}
9879 : !> \include{lineno} example/pm_arrayRank/setRankStandard/main.F90
9880 : !> \compilef{setRankStandard}
9881 : !> \output{setRankStandard}
9882 : !> \include{lineno} example/pm_arrayRank/setRankStandard/main.out.F90
9883 : !>
9884 : !> \test
9885 : !> [test_pm_arrayRank](@ref test_pm_arrayRank)
9886 : !>
9887 : !> \bug
9888 : !> \status \unresolved
9889 : !> \source \ifort{2021.5}
9890 : !> \desc
9891 : !> See [pm_arraySplit](@ref pm_arraySplit) for the description of a relevant bug in PDT
9892 : !> name aliasing when compiled with Intel ifort 2021.5 that also applies to this module.
9893 : !> \remedy
9894 : !> See [pm_arraySplit](@ref pm_arraySplit) for the remedy.<br>
9895 : !>
9896 : !> \todo
9897 : !> \plow The current bypass for the PDT name aliasing bug can be reverted back to PDT name aliasing once the ifort bug is resolved.
9898 : !>
9899 : !> \todo
9900 : !> \plow A test should be implemented for arrays of size that can be represented *only* by an \IKD integer.
9901 : !>
9902 : !> \finmain{setRankStandard}
9903 : !>
9904 : !> \author
9905 : !> \AmirShahmoradi, April 21, 2017, 1:54 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
9906 : interface setRankStandard
9907 :
9908 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9909 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9910 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9911 :
9912 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9913 :
9914 : #if SK5_ENABLED
9915 : PURE module subroutine setRankStandardDefCom_D0_SK5(rank, array)
9916 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9917 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D0_SK5
9918 : #endif
9919 : use pm_kind, only: TKR => IK, SKC => SK5
9920 : character(*,SKC) , intent(in) :: array
9921 : integer(TKR) , intent(out) , contiguous :: rank(:)
9922 : end subroutine
9923 : #endif
9924 :
9925 : #if SK4_ENABLED
9926 : PURE module subroutine setRankStandardDefCom_D0_SK4(rank, array)
9927 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9928 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D0_SK4
9929 : #endif
9930 : use pm_kind, only: TKR => IK, SKC => SK4
9931 : character(*,SKC) , intent(in) :: array
9932 : integer(TKR) , intent(out) , contiguous :: rank(:)
9933 : end subroutine
9934 : #endif
9935 :
9936 : #if SK3_ENABLED
9937 : PURE module subroutine setRankStandardDefCom_D0_SK3(rank, array)
9938 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9939 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D0_SK3
9940 : #endif
9941 : use pm_kind, only: TKR => IK, SKC => SK3
9942 : character(*,SKC) , intent(in) :: array
9943 : integer(TKR) , intent(out) , contiguous :: rank(:)
9944 : end subroutine
9945 : #endif
9946 :
9947 : #if SK2_ENABLED
9948 : PURE module subroutine setRankStandardDefCom_D0_SK2(rank, array)
9949 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9950 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D0_SK2
9951 : #endif
9952 : use pm_kind, only: TKR => IK, SKC => SK2
9953 : character(*,SKC) , intent(in) :: array
9954 : integer(TKR) , intent(out) , contiguous :: rank(:)
9955 : end subroutine
9956 : #endif
9957 :
9958 : #if SK1_ENABLED
9959 : PURE module subroutine setRankStandardDefCom_D0_SK1(rank, array)
9960 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9961 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D0_SK1
9962 : #endif
9963 : use pm_kind, only: TKR => IK, SKC => SK1
9964 : character(*,SKC) , intent(in) :: array
9965 : integer(TKR) , intent(out) , contiguous :: rank(:)
9966 : end subroutine
9967 : #endif
9968 :
9969 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
9970 :
9971 : #if SK5_ENABLED
9972 : PURE module subroutine setRankStandardDefCom_D1_SK5(rank, array)
9973 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9974 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_SK5
9975 : #endif
9976 : use pm_kind, only: TKR => IK, SKC => SK5
9977 : character(*,SKC) , intent(in) , contiguous :: array(:)
9978 : integer(TKR) , intent(out) , contiguous :: rank(:)
9979 : end subroutine
9980 : #endif
9981 :
9982 : #if SK4_ENABLED
9983 : PURE module subroutine setRankStandardDefCom_D1_SK4(rank, array)
9984 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9985 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_SK4
9986 : #endif
9987 : use pm_kind, only: TKR => IK, SKC => SK4
9988 : character(*,SKC) , intent(in) , contiguous :: array(:)
9989 : integer(TKR) , intent(out) , contiguous :: rank(:)
9990 : end subroutine
9991 : #endif
9992 :
9993 : #if SK3_ENABLED
9994 : PURE module subroutine setRankStandardDefCom_D1_SK3(rank, array)
9995 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
9996 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_SK3
9997 : #endif
9998 : use pm_kind, only: TKR => IK, SKC => SK3
9999 : character(*,SKC) , intent(in) , contiguous :: array(:)
10000 : integer(TKR) , intent(out) , contiguous :: rank(:)
10001 : end subroutine
10002 : #endif
10003 :
10004 : #if SK2_ENABLED
10005 : PURE module subroutine setRankStandardDefCom_D1_SK2(rank, array)
10006 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10007 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_SK2
10008 : #endif
10009 : use pm_kind, only: TKR => IK, SKC => SK2
10010 : character(*,SKC) , intent(in) , contiguous :: array(:)
10011 : integer(TKR) , intent(out) , contiguous :: rank(:)
10012 : end subroutine
10013 : #endif
10014 :
10015 : #if SK1_ENABLED
10016 : PURE module subroutine setRankStandardDefCom_D1_SK1(rank, array)
10017 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10018 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_SK1
10019 : #endif
10020 : use pm_kind, only: TKR => IK, SKC => SK1
10021 : character(*,SKC) , intent(in) , contiguous :: array(:)
10022 : integer(TKR) , intent(out) , contiguous :: rank(:)
10023 : end subroutine
10024 : #endif
10025 :
10026 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10027 :
10028 : #if IK5_ENABLED
10029 : PURE module subroutine setRankStandardDefCom_D1_IK5(rank, array)
10030 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10031 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_IK5
10032 : #endif
10033 : use pm_kind, only: TKR => IK, IKC => IK5
10034 : integer(IKC) , intent(in) , contiguous :: array(:)
10035 : integer(TKR) , intent(out) , contiguous :: rank(:)
10036 : end subroutine
10037 : #endif
10038 :
10039 : #if IK4_ENABLED
10040 : PURE module subroutine setRankStandardDefCom_D1_IK4(rank, array)
10041 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10042 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_IK4
10043 : #endif
10044 : use pm_kind, only: TKR => IK, IKC => IK4
10045 : integer(IKC) , intent(in) , contiguous :: array(:)
10046 : integer(TKR) , intent(out) , contiguous :: rank(:)
10047 : end subroutine
10048 : #endif
10049 :
10050 : #if IK3_ENABLED
10051 : PURE module subroutine setRankStandardDefCom_D1_IK3(rank, array)
10052 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10053 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_IK3
10054 : #endif
10055 : use pm_kind, only: TKR => IK, IKC => IK3
10056 : integer(IKC) , intent(in) , contiguous :: array(:)
10057 : integer(TKR) , intent(out) , contiguous :: rank(:)
10058 : end subroutine
10059 : #endif
10060 :
10061 : #if IK2_ENABLED
10062 : PURE module subroutine setRankStandardDefCom_D1_IK2(rank, array)
10063 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10064 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_IK2
10065 : #endif
10066 : use pm_kind, only: TKR => IK, IKC => IK2
10067 : integer(IKC) , intent(in) , contiguous :: array(:)
10068 : integer(TKR) , intent(out) , contiguous :: rank(:)
10069 : end subroutine
10070 : #endif
10071 :
10072 : #if IK1_ENABLED
10073 : PURE module subroutine setRankStandardDefCom_D1_IK1(rank, array)
10074 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10075 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_IK1
10076 : #endif
10077 : use pm_kind, only: TKR => IK, IKC => IK1
10078 : integer(IKC) , intent(in) , contiguous :: array(:)
10079 : integer(TKR) , intent(out) , contiguous :: rank(:)
10080 : end subroutine
10081 : #endif
10082 :
10083 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10084 :
10085 : #if LK5_ENABLED
10086 : PURE module subroutine setRankStandardDefCom_D1_LK5(rank, array)
10087 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10088 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_LK5
10089 : #endif
10090 : use pm_kind, only: TKR => IK, LKC => LK5
10091 : logical(LKC) , intent(in) , contiguous :: array(:)
10092 : integer(TKR) , intent(out) , contiguous :: rank(:)
10093 : end subroutine
10094 : #endif
10095 :
10096 : #if LK4_ENABLED
10097 : PURE module subroutine setRankStandardDefCom_D1_LK4(rank, array)
10098 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10099 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_LK4
10100 : #endif
10101 : use pm_kind, only: TKR => IK, LKC => LK4
10102 : logical(LKC) , intent(in) , contiguous :: array(:)
10103 : integer(TKR) , intent(out) , contiguous :: rank(:)
10104 : end subroutine
10105 : #endif
10106 :
10107 : #if LK3_ENABLED
10108 : PURE module subroutine setRankStandardDefCom_D1_LK3(rank, array)
10109 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10110 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_LK3
10111 : #endif
10112 : use pm_kind, only: TKR => IK, LKC => LK3
10113 : logical(LKC) , intent(in) , contiguous :: array(:)
10114 : integer(TKR) , intent(out) , contiguous :: rank(:)
10115 : end subroutine
10116 : #endif
10117 :
10118 : #if LK2_ENABLED
10119 : PURE module subroutine setRankStandardDefCom_D1_LK2(rank, array)
10120 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10121 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_LK2
10122 : #endif
10123 : use pm_kind, only: TKR => IK, LKC => LK2
10124 : logical(LKC) , intent(in) , contiguous :: array(:)
10125 : integer(TKR) , intent(out) , contiguous :: rank(:)
10126 : end subroutine
10127 : #endif
10128 :
10129 : #if LK1_ENABLED
10130 : PURE module subroutine setRankStandardDefCom_D1_LK1(rank, array)
10131 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10132 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_LK1
10133 : #endif
10134 : use pm_kind, only: TKR => IK, LKC => LK1
10135 : logical(LKC) , intent(in) , contiguous :: array(:)
10136 : integer(TKR) , intent(out) , contiguous :: rank(:)
10137 : end subroutine
10138 : #endif
10139 :
10140 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10141 :
10142 : #if CK5_ENABLED
10143 : PURE module subroutine setRankStandardDefCom_D1_CK5(rank, array)
10144 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10145 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_CK5
10146 : #endif
10147 : use pm_kind, only: TKR => IK, CKC => CK5
10148 : complex(CKC) , intent(in) , contiguous :: array(:)
10149 : integer(TKR) , intent(out) , contiguous :: rank(:)
10150 : end subroutine
10151 : #endif
10152 :
10153 : #if CK4_ENABLED
10154 : PURE module subroutine setRankStandardDefCom_D1_CK4(rank, array)
10155 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10156 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_CK4
10157 : #endif
10158 : use pm_kind, only: TKR => IK, CKC => CK4
10159 : complex(CKC) , intent(in) , contiguous :: array(:)
10160 : integer(TKR) , intent(out) , contiguous :: rank(:)
10161 : end subroutine
10162 : #endif
10163 :
10164 : #if CK3_ENABLED
10165 : PURE module subroutine setRankStandardDefCom_D1_CK3(rank, array)
10166 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10167 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_CK3
10168 : #endif
10169 : use pm_kind, only: TKR => IK, CKC => CK3
10170 : complex(CKC) , intent(in) , contiguous :: array(:)
10171 : integer(TKR) , intent(out) , contiguous :: rank(:)
10172 : end subroutine
10173 : #endif
10174 :
10175 : #if CK2_ENABLED
10176 : PURE module subroutine setRankStandardDefCom_D1_CK2(rank, array)
10177 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10178 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_CK2
10179 : #endif
10180 : use pm_kind, only: TKR => IK, CKC => CK2
10181 : complex(CKC) , intent(in) , contiguous :: array(:)
10182 : integer(TKR) , intent(out) , contiguous :: rank(:)
10183 : end subroutine
10184 : #endif
10185 :
10186 : #if CK1_ENABLED
10187 : PURE module subroutine setRankStandardDefCom_D1_CK1(rank, array)
10188 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10189 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_CK1
10190 : #endif
10191 : use pm_kind, only: TKR => IK, CKC => CK1
10192 : complex(CKC) , intent(in) , contiguous :: array(:)
10193 : integer(TKR) , intent(out) , contiguous :: rank(:)
10194 : end subroutine
10195 : #endif
10196 :
10197 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10198 :
10199 : #if RK5_ENABLED
10200 : PURE module subroutine setRankStandardDefCom_D1_RK5(rank, array)
10201 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10202 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_RK5
10203 : #endif
10204 : use pm_kind, only: TKR => IK, RKC => RK5
10205 : real(RKC) , intent(in) , contiguous :: array(:)
10206 : integer(TKR) , intent(out) , contiguous :: rank(:)
10207 : end subroutine
10208 : #endif
10209 :
10210 : #if RK4_ENABLED
10211 : PURE module subroutine setRankStandardDefCom_D1_RK4(rank, array)
10212 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10213 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_RK4
10214 : #endif
10215 : use pm_kind, only: TKR => IK, RKC => RK4
10216 : real(RKC) , intent(in) , contiguous :: array(:)
10217 : integer(TKR) , intent(out) , contiguous :: rank(:)
10218 : end subroutine
10219 : #endif
10220 :
10221 : #if RK3_ENABLED
10222 : PURE module subroutine setRankStandardDefCom_D1_RK3(rank, array)
10223 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10224 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_RK3
10225 : #endif
10226 : use pm_kind, only: TKR => IK, RKC => RK3
10227 : real(RKC) , intent(in) , contiguous :: array(:)
10228 : integer(TKR) , intent(out) , contiguous :: rank(:)
10229 : end subroutine
10230 : #endif
10231 :
10232 : #if RK2_ENABLED
10233 : PURE module subroutine setRankStandardDefCom_D1_RK2(rank, array)
10234 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10235 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_RK2
10236 : #endif
10237 : use pm_kind, only: TKR => IK, RKC => RK2
10238 : real(RKC) , intent(in) , contiguous :: array(:)
10239 : integer(TKR) , intent(out) , contiguous :: rank(:)
10240 : end subroutine
10241 : #endif
10242 :
10243 : #if RK1_ENABLED
10244 : PURE module subroutine setRankStandardDefCom_D1_RK1(rank, array)
10245 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10246 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_RK1
10247 : #endif
10248 : use pm_kind, only: TKR => IK, RKC => RK1
10249 : real(RKC) , intent(in) , contiguous :: array(:)
10250 : integer(TKR) , intent(out) , contiguous :: rank(:)
10251 : end subroutine
10252 : #endif
10253 :
10254 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10255 :
10256 : #if SK5_ENABLED
10257 : PURE module subroutine setRankStandardDefCom_D1_PSSK5(rank, array)
10258 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10259 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_PSSK5
10260 : #endif
10261 : use pm_kind, only: TKR => IK, SKC => SK5
10262 : use pm_container, only: css_pdt
10263 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10264 : integer(TKR) , intent(out) , contiguous :: rank(:)
10265 : end subroutine
10266 : #endif
10267 :
10268 : #if SK4_ENABLED
10269 : PURE module subroutine setRankStandardDefCom_D1_PSSK4(rank, array)
10270 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10271 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_PSSK4
10272 : #endif
10273 : use pm_kind, only: TKR => IK, SKC => SK4
10274 : use pm_container, only: css_pdt
10275 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10276 : integer(TKR) , intent(out) , contiguous :: rank(:)
10277 : end subroutine
10278 : #endif
10279 :
10280 : #if SK3_ENABLED
10281 : PURE module subroutine setRankStandardDefCom_D1_PSSK3(rank, array)
10282 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10283 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_PSSK3
10284 : #endif
10285 : use pm_kind, only: TKR => IK, SKC => SK3
10286 : use pm_container, only: css_pdt
10287 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10288 : integer(TKR) , intent(out) , contiguous :: rank(:)
10289 : end subroutine
10290 : #endif
10291 :
10292 : #if SK2_ENABLED
10293 : PURE module subroutine setRankStandardDefCom_D1_PSSK2(rank, array)
10294 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10295 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_PSSK2
10296 : #endif
10297 : use pm_kind, only: TKR => IK, SKC => SK2
10298 : use pm_container, only: css_pdt
10299 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10300 : integer(TKR) , intent(out) , contiguous :: rank(:)
10301 : end subroutine
10302 : #endif
10303 :
10304 : #if SK1_ENABLED
10305 : PURE module subroutine setRankStandardDefCom_D1_PSSK1(rank, array)
10306 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10307 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_PSSK1
10308 : #endif
10309 : use pm_kind, only: TKR => IK, SKC => SK1
10310 : use pm_container, only: css_pdt
10311 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10312 : integer(TKR) , intent(out) , contiguous :: rank(:)
10313 : end subroutine
10314 : #endif
10315 :
10316 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10317 :
10318 : PURE module subroutine setRankStandardDefCom_D1_BSSK(rank, array)
10319 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10320 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardDefCom_D1_BSSK
10321 : #endif
10322 : use pm_kind, only: TKR => IK, SKC => SK
10323 : use pm_container, only: css_type
10324 : type(css_type) , intent(in) , contiguous :: array(:)
10325 : integer(TKR) , intent(out) , contiguous :: rank(:)
10326 : end subroutine
10327 :
10328 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10329 :
10330 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10331 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10332 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10333 :
10334 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10335 :
10336 : #if SK5_ENABLED
10337 : module subroutine setRankStandardCusCom_D0_SK5(rank, array, isSorted)
10338 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10339 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D0_SK5
10340 : #endif
10341 : use pm_kind, only: TKR => IK, SKC => SK5
10342 : character(*,SKC) , intent(in) :: array
10343 : integer(TKR) , intent(out) , contiguous :: rank(:)
10344 : procedure(logical(LK)) :: isSorted
10345 : end subroutine
10346 : #endif
10347 :
10348 : #if SK4_ENABLED
10349 : module subroutine setRankStandardCusCom_D0_SK4(rank, array, isSorted)
10350 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10351 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D0_SK4
10352 : #endif
10353 : use pm_kind, only: TKR => IK, SKC => SK4
10354 : character(*,SKC) , intent(in) :: array
10355 : integer(TKR) , intent(out) , contiguous :: rank(:)
10356 : procedure(logical(LK)) :: isSorted
10357 : end subroutine
10358 : #endif
10359 :
10360 : #if SK3_ENABLED
10361 : module subroutine setRankStandardCusCom_D0_SK3(rank, array, isSorted)
10362 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10363 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D0_SK3
10364 : #endif
10365 : use pm_kind, only: TKR => IK, SKC => SK3
10366 : character(*,SKC) , intent(in) :: array
10367 : integer(TKR) , intent(out) , contiguous :: rank(:)
10368 : procedure(logical(LK)) :: isSorted
10369 : end subroutine
10370 : #endif
10371 :
10372 : #if SK2_ENABLED
10373 : module subroutine setRankStandardCusCom_D0_SK2(rank, array, isSorted)
10374 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10375 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D0_SK2
10376 : #endif
10377 : use pm_kind, only: TKR => IK, SKC => SK2
10378 : character(*,SKC) , intent(in) :: array
10379 : integer(TKR) , intent(out) , contiguous :: rank(:)
10380 : procedure(logical(LK)) :: isSorted
10381 : end subroutine
10382 : #endif
10383 :
10384 : #if SK1_ENABLED
10385 : module subroutine setRankStandardCusCom_D0_SK1(rank, array, isSorted)
10386 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10387 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D0_SK1
10388 : #endif
10389 : use pm_kind, only: TKR => IK, SKC => SK1
10390 : character(*,SKC) , intent(in) :: array
10391 : integer(TKR) , intent(out) , contiguous :: rank(:)
10392 : procedure(logical(LK)) :: isSorted
10393 : end subroutine
10394 : #endif
10395 :
10396 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10397 :
10398 : #if SK5_ENABLED
10399 : module subroutine setRankStandardCusCom_D1_SK5(rank, array, isSorted)
10400 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10401 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_SK5
10402 : #endif
10403 : use pm_kind, only: TKR => IK, SKC => SK5
10404 : character(*,SKC) , intent(in) , contiguous :: array(:)
10405 : integer(TKR) , intent(out) , contiguous :: rank(:)
10406 : procedure(logical(LK)) :: isSorted
10407 : end subroutine
10408 : #endif
10409 :
10410 : #if SK4_ENABLED
10411 : module subroutine setRankStandardCusCom_D1_SK4(rank, array, isSorted)
10412 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10413 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_SK4
10414 : #endif
10415 : use pm_kind, only: TKR => IK, SKC => SK4
10416 : character(*,SKC) , intent(in) , contiguous :: array(:)
10417 : integer(TKR) , intent(out) , contiguous :: rank(:)
10418 : procedure(logical(LK)) :: isSorted
10419 : end subroutine
10420 : #endif
10421 :
10422 : #if SK3_ENABLED
10423 : module subroutine setRankStandardCusCom_D1_SK3(rank, array, isSorted)
10424 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10425 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_SK3
10426 : #endif
10427 : use pm_kind, only: TKR => IK, SKC => SK3
10428 : character(*,SKC) , intent(in) , contiguous :: array(:)
10429 : integer(TKR) , intent(out) , contiguous :: rank(:)
10430 : procedure(logical(LK)) :: isSorted
10431 : end subroutine
10432 : #endif
10433 :
10434 : #if SK2_ENABLED
10435 : module subroutine setRankStandardCusCom_D1_SK2(rank, array, isSorted)
10436 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10437 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_SK2
10438 : #endif
10439 : use pm_kind, only: TKR => IK, SKC => SK2
10440 : character(*,SKC) , intent(in) , contiguous :: array(:)
10441 : integer(TKR) , intent(out) , contiguous :: rank(:)
10442 : procedure(logical(LK)) :: isSorted
10443 : end subroutine
10444 : #endif
10445 :
10446 : #if SK1_ENABLED
10447 : module subroutine setRankStandardCusCom_D1_SK1(rank, array, isSorted)
10448 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10449 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_SK1
10450 : #endif
10451 : use pm_kind, only: TKR => IK, SKC => SK1
10452 : character(*,SKC) , intent(in) , contiguous :: array(:)
10453 : integer(TKR) , intent(out) , contiguous :: rank(:)
10454 : procedure(logical(LK)) :: isSorted
10455 : end subroutine
10456 : #endif
10457 :
10458 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10459 :
10460 : #if IK5_ENABLED
10461 : module subroutine setRankStandardCusCom_D1_IK5(rank, array, isSorted)
10462 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10463 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_IK5
10464 : #endif
10465 : use pm_kind, only: TKR => IK, IKC => IK5
10466 : integer(IKC) , intent(in) , contiguous :: array(:)
10467 : integer(TKR) , intent(out) , contiguous :: rank(:)
10468 : procedure(logical(LK)) :: isSorted
10469 : end subroutine
10470 : #endif
10471 :
10472 : #if IK4_ENABLED
10473 : module subroutine setRankStandardCusCom_D1_IK4(rank, array, isSorted)
10474 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10475 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_IK4
10476 : #endif
10477 : use pm_kind, only: TKR => IK, IKC => IK4
10478 : integer(IKC) , intent(in) , contiguous :: array(:)
10479 : integer(TKR) , intent(out) , contiguous :: rank(:)
10480 : procedure(logical(LK)) :: isSorted
10481 : end subroutine
10482 : #endif
10483 :
10484 : #if IK3_ENABLED
10485 : module subroutine setRankStandardCusCom_D1_IK3(rank, array, isSorted)
10486 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10487 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_IK3
10488 : #endif
10489 : use pm_kind, only: TKR => IK, IKC => IK3
10490 : integer(IKC) , intent(in) , contiguous :: array(:)
10491 : integer(TKR) , intent(out) , contiguous :: rank(:)
10492 : procedure(logical(LK)) :: isSorted
10493 : end subroutine
10494 : #endif
10495 :
10496 : #if IK2_ENABLED
10497 : module subroutine setRankStandardCusCom_D1_IK2(rank, array, isSorted)
10498 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10499 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_IK2
10500 : #endif
10501 : use pm_kind, only: TKR => IK, IKC => IK2
10502 : integer(IKC) , intent(in) , contiguous :: array(:)
10503 : integer(TKR) , intent(out) , contiguous :: rank(:)
10504 : procedure(logical(LK)) :: isSorted
10505 : end subroutine
10506 : #endif
10507 :
10508 : #if IK1_ENABLED
10509 : module subroutine setRankStandardCusCom_D1_IK1(rank, array, isSorted)
10510 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10511 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_IK1
10512 : #endif
10513 : use pm_kind, only: TKR => IK, IKC => IK1
10514 : integer(IKC) , intent(in) , contiguous :: array(:)
10515 : integer(TKR) , intent(out) , contiguous :: rank(:)
10516 : procedure(logical(LK)) :: isSorted
10517 : end subroutine
10518 : #endif
10519 :
10520 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10521 :
10522 : #if LK5_ENABLED
10523 : module subroutine setRankStandardCusCom_D1_LK5(rank, array, isSorted)
10524 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10525 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_LK5
10526 : #endif
10527 : use pm_kind, only: TKR => IK, LKC => LK5
10528 : logical(LKC) , intent(in) , contiguous :: array(:)
10529 : integer(TKR) , intent(out) , contiguous :: rank(:)
10530 : procedure(logical(LK)) :: isSorted
10531 : end subroutine
10532 : #endif
10533 :
10534 : #if LK4_ENABLED
10535 : module subroutine setRankStandardCusCom_D1_LK4(rank, array, isSorted)
10536 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10537 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_LK4
10538 : #endif
10539 : use pm_kind, only: TKR => IK, LKC => LK4
10540 : logical(LKC) , intent(in) , contiguous :: array(:)
10541 : integer(TKR) , intent(out) , contiguous :: rank(:)
10542 : procedure(logical(LK)) :: isSorted
10543 : end subroutine
10544 : #endif
10545 :
10546 : #if LK3_ENABLED
10547 : module subroutine setRankStandardCusCom_D1_LK3(rank, array, isSorted)
10548 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10549 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_LK3
10550 : #endif
10551 : use pm_kind, only: TKR => IK, LKC => LK3
10552 : logical(LKC) , intent(in) , contiguous :: array(:)
10553 : integer(TKR) , intent(out) , contiguous :: rank(:)
10554 : procedure(logical(LK)) :: isSorted
10555 : end subroutine
10556 : #endif
10557 :
10558 : #if LK2_ENABLED
10559 : module subroutine setRankStandardCusCom_D1_LK2(rank, array, isSorted)
10560 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10561 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_LK2
10562 : #endif
10563 : use pm_kind, only: TKR => IK, LKC => LK2
10564 : logical(LKC) , intent(in) , contiguous :: array(:)
10565 : integer(TKR) , intent(out) , contiguous :: rank(:)
10566 : procedure(logical(LK)) :: isSorted
10567 : end subroutine
10568 : #endif
10569 :
10570 : #if LK1_ENABLED
10571 : module subroutine setRankStandardCusCom_D1_LK1(rank, array, isSorted)
10572 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10573 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_LK1
10574 : #endif
10575 : use pm_kind, only: TKR => IK, LKC => LK1
10576 : logical(LKC) , intent(in) , contiguous :: array(:)
10577 : integer(TKR) , intent(out) , contiguous :: rank(:)
10578 : procedure(logical(LK)) :: isSorted
10579 : end subroutine
10580 : #endif
10581 :
10582 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10583 :
10584 : #if CK5_ENABLED
10585 : module subroutine setRankStandardCusCom_D1_CK5(rank, array, isSorted)
10586 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10587 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_CK5
10588 : #endif
10589 : use pm_kind, only: TKR => IK, CKC => CK5
10590 : complex(CKC) , intent(in) , contiguous :: array(:)
10591 : integer(TKR) , intent(out) , contiguous :: rank(:)
10592 : procedure(logical(LK)) :: isSorted
10593 : end subroutine
10594 : #endif
10595 :
10596 : #if CK4_ENABLED
10597 : module subroutine setRankStandardCusCom_D1_CK4(rank, array, isSorted)
10598 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10599 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_CK4
10600 : #endif
10601 : use pm_kind, only: TKR => IK, CKC => CK4
10602 : complex(CKC) , intent(in) , contiguous :: array(:)
10603 : integer(TKR) , intent(out) , contiguous :: rank(:)
10604 : procedure(logical(LK)) :: isSorted
10605 : end subroutine
10606 : #endif
10607 :
10608 : #if CK3_ENABLED
10609 : module subroutine setRankStandardCusCom_D1_CK3(rank, array, isSorted)
10610 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10611 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_CK3
10612 : #endif
10613 : use pm_kind, only: TKR => IK, CKC => CK3
10614 : complex(CKC) , intent(in) , contiguous :: array(:)
10615 : integer(TKR) , intent(out) , contiguous :: rank(:)
10616 : procedure(logical(LK)) :: isSorted
10617 : end subroutine
10618 : #endif
10619 :
10620 : #if CK2_ENABLED
10621 : module subroutine setRankStandardCusCom_D1_CK2(rank, array, isSorted)
10622 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10623 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_CK2
10624 : #endif
10625 : use pm_kind, only: TKR => IK, CKC => CK2
10626 : complex(CKC) , intent(in) , contiguous :: array(:)
10627 : integer(TKR) , intent(out) , contiguous :: rank(:)
10628 : procedure(logical(LK)) :: isSorted
10629 : end subroutine
10630 : #endif
10631 :
10632 : #if CK1_ENABLED
10633 : module subroutine setRankStandardCusCom_D1_CK1(rank, array, isSorted)
10634 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10635 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_CK1
10636 : #endif
10637 : use pm_kind, only: TKR => IK, CKC => CK1
10638 : complex(CKC) , intent(in) , contiguous :: array(:)
10639 : integer(TKR) , intent(out) , contiguous :: rank(:)
10640 : procedure(logical(LK)) :: isSorted
10641 : end subroutine
10642 : #endif
10643 :
10644 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10645 :
10646 : #if RK5_ENABLED
10647 : module subroutine setRankStandardCusCom_D1_RK5(rank, array, isSorted)
10648 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10649 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_RK5
10650 : #endif
10651 : use pm_kind, only: TKR => IK, RKC => RK5
10652 : real(RKC) , intent(in) , contiguous :: array(:)
10653 : integer(TKR) , intent(out) , contiguous :: rank(:)
10654 : procedure(logical(LK)) :: isSorted
10655 : end subroutine
10656 : #endif
10657 :
10658 : #if RK4_ENABLED
10659 : module subroutine setRankStandardCusCom_D1_RK4(rank, array, isSorted)
10660 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10661 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_RK4
10662 : #endif
10663 : use pm_kind, only: TKR => IK, RKC => RK4
10664 : real(RKC) , intent(in) , contiguous :: array(:)
10665 : integer(TKR) , intent(out) , contiguous :: rank(:)
10666 : procedure(logical(LK)) :: isSorted
10667 : end subroutine
10668 : #endif
10669 :
10670 : #if RK3_ENABLED
10671 : module subroutine setRankStandardCusCom_D1_RK3(rank, array, isSorted)
10672 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10673 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_RK3
10674 : #endif
10675 : use pm_kind, only: TKR => IK, RKC => RK3
10676 : real(RKC) , intent(in) , contiguous :: array(:)
10677 : integer(TKR) , intent(out) , contiguous :: rank(:)
10678 : procedure(logical(LK)) :: isSorted
10679 : end subroutine
10680 : #endif
10681 :
10682 : #if RK2_ENABLED
10683 : module subroutine setRankStandardCusCom_D1_RK2(rank, array, isSorted)
10684 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10685 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_RK2
10686 : #endif
10687 : use pm_kind, only: TKR => IK, RKC => RK2
10688 : real(RKC) , intent(in) , contiguous :: array(:)
10689 : integer(TKR) , intent(out) , contiguous :: rank(:)
10690 : procedure(logical(LK)) :: isSorted
10691 : end subroutine
10692 : #endif
10693 :
10694 : #if RK1_ENABLED
10695 : module subroutine setRankStandardCusCom_D1_RK1(rank, array, isSorted)
10696 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10697 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_RK1
10698 : #endif
10699 : use pm_kind, only: TKR => IK, RKC => RK1
10700 : real(RKC) , intent(in) , contiguous :: array(:)
10701 : integer(TKR) , intent(out) , contiguous :: rank(:)
10702 : procedure(logical(LK)) :: isSorted
10703 : end subroutine
10704 : #endif
10705 :
10706 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10707 :
10708 : #if SK5_ENABLED
10709 : module subroutine setRankStandardCusCom_D1_PSSK5(rank, array, isSorted)
10710 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10711 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_PSSK5
10712 : #endif
10713 : use pm_kind, only: TKR => IK, SKC => SK5
10714 : use pm_container, only: css_pdt
10715 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10716 : integer(TKR) , intent(out) , contiguous :: rank(:)
10717 : procedure(logical(LK)) :: isSorted
10718 : end subroutine
10719 : #endif
10720 :
10721 : #if SK4_ENABLED
10722 : module subroutine setRankStandardCusCom_D1_PSSK4(rank, array, isSorted)
10723 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10724 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_PSSK4
10725 : #endif
10726 : use pm_kind, only: TKR => IK, SKC => SK4
10727 : use pm_container, only: css_pdt
10728 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10729 : integer(TKR) , intent(out) , contiguous :: rank(:)
10730 : procedure(logical(LK)) :: isSorted
10731 : end subroutine
10732 : #endif
10733 :
10734 : #if SK3_ENABLED
10735 : module subroutine setRankStandardCusCom_D1_PSSK3(rank, array, isSorted)
10736 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10737 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_PSSK3
10738 : #endif
10739 : use pm_kind, only: TKR => IK, SKC => SK3
10740 : use pm_container, only: css_pdt
10741 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10742 : integer(TKR) , intent(out) , contiguous :: rank(:)
10743 : procedure(logical(LK)) :: isSorted
10744 : end subroutine
10745 : #endif
10746 :
10747 : #if SK2_ENABLED
10748 : module subroutine setRankStandardCusCom_D1_PSSK2(rank, array, isSorted)
10749 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10750 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_PSSK2
10751 : #endif
10752 : use pm_kind, only: TKR => IK, SKC => SK2
10753 : use pm_container, only: css_pdt
10754 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10755 : integer(TKR) , intent(out) , contiguous :: rank(:)
10756 : procedure(logical(LK)) :: isSorted
10757 : end subroutine
10758 : #endif
10759 :
10760 : #if SK1_ENABLED
10761 : module subroutine setRankStandardCusCom_D1_PSSK1(rank, array, isSorted)
10762 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10763 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_PSSK1
10764 : #endif
10765 : use pm_kind, only: TKR => IK, SKC => SK1
10766 : use pm_container, only: css_pdt
10767 : type(css_pdt(SKC)) , intent(in) , contiguous :: array(:)
10768 : integer(TKR) , intent(out) , contiguous :: rank(:)
10769 : procedure(logical(LK)) :: isSorted
10770 : end subroutine
10771 : #endif
10772 :
10773 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10774 :
10775 : module subroutine setRankStandardCusCom_D1_BSSK(rank, array, isSorted)
10776 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
10777 : !DEC$ ATTRIBUTES DLLEXPORT :: setRankStandardCusCom_D1_BSSK
10778 : #endif
10779 : use pm_kind, only: TKR => IK, SKC => SK
10780 : use pm_container, only: css_type
10781 : type(css_type) , intent(in) , contiguous :: array(:)
10782 : integer(TKR) , intent(out) , contiguous :: rank(:)
10783 : procedure(logical(LK)) :: isSorted
10784 : end subroutine
10785 :
10786 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10787 :
10788 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10789 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10790 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10791 :
10792 : end interface
10793 :
10794 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
10795 :
10796 0 : end module pm_arrayRank
|
