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 the uncommon and hardly representable ASCII characters as well as
19 : !> procedures for operating on strings that exclusively contain the 128 ASCII characters.<br>
20 : !>
21 : !> \details
22 : !> ASCII, stands for American Standard Code for Information Interchange.<br>
23 : !> It is a 7-bit character code where every single bit represents a unique character.<br>
24 : !> The first 32 characters in the ASCII-table are unprintable control codes and are used to control peripherals such as printers.<br>
25 : !> ASCII printable characters (character code 32-127) Codes 32-127 are common for all the different variations of the ASCII table,
26 : !> they are called printable characters, represent letters, digits, punctuation marks, and a few miscellaneous symbols.<br>
27 : !> You will find almost every character on your keyboard. Character 127 represents the command DEL.<br>
28 : !>
29 : !> \see
30 : !> [pm_distUnif](@ref pm_distUnif) for uniformly-distributed random character generation.<br>
31 : !> [https://www.ascii-code.com/](https://www.ascii-code.com/) for information about ASCII characters.<br>
32 : !>
33 : !> \benchmarks
34 : !>
35 : !> \benchmark{getStrLower_vs_setStrLower, The runtime performance of [getStrLower](@ref pm_strASCII::getStrLower) vs. [setStrLower](@ref pm_strASCII::setStrLower)}
36 : !> \include{lineno} benchmark/pm_strASCII/getStrLower_vs_setStrLower/main.F90
37 : !> \compilefb{getStrLower_vs_setStrLower}
38 : !> \postprocb{getStrLower_vs_setStrLower}
39 : !> \include{lineno} benchmark/pm_strASCII/getStrLower_vs_setStrLower/main.py
40 : !> \visb{getStrLower_vs_setStrLower}
41 : !> \image html benchmark/pm_strASCII/getStrLower_vs_setStrLower/benchmark.getStrLower_vs_setStrLower.runtime.png width=1000
42 : !> \image html benchmark/pm_strASCII/getStrLower_vs_setStrLower/benchmark.getStrLower_vs_setStrLower.runtime.ratio.png width=1000
43 : !> \moralb{getStrLower_vs_setStrLower}
44 : !> -# The procedure [getStrLower](@ref pm_strASCII::getStrLower) is a function while
45 : !> the procedure [setStrLower](@ref pm_strASCII::setStrLower) is a subroutines.<br>
46 : !> From the benchmark results, it appears that the functional interface performs less efficiently than
47 : !> the subroutine interface when the input `array` size is small (\f$<300\f$).<br>
48 : !> Nevertheless, the difference appears to diminish or even change its course for large string sizes.<br>
49 : !> -# The results of this benchmark are equally applicable to the [getStrUpper](@ref getStrUpper) vs. [setStrUpper](@ref setStrUpper).<br>
50 : !>
51 : !> \test
52 : !> [test_pm_strASCII](@ref test_pm_strASCII)
53 : !>
54 : !> \finmain
55 : !>
56 : !> \author
57 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
58 :
59 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
60 :
61 : module pm_strASCII
62 :
63 : use pm_kind, only: SK, IK, LK
64 :
65 : implicit none
66 :
67 : !> \cond excluded
68 : integer, private :: i
69 : !> \endcond excluded
70 :
71 : character(*, SK), parameter :: MODULE_NAME = SK_"@pm_strASCII"
72 :
73 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
74 :
75 : integer(IK) , parameter :: MAX_ASCII_CODE = 127_IK !< \public The scalar `integer` constant of default kind \IK representing the maximum standard ASCII code.<br>
76 :
77 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
78 :
79 : ! ASCII Control characters.
80 :
81 : character(1, SK), parameter :: NUL = achar(0, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Null character.<br>
82 : !< \warning This is a dangerous character that has a special meaning to C-processors and some Fortran compilers like ifort.<br>
83 : !< As such, it should never be used in any string unless the consequences are fully understood.<br>
84 : character(1, SK), parameter :: SOH = achar(1, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Start of Heading.<br>
85 : character(1, SK), parameter :: STX = achar(2, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Start of Text.<br>
86 : character(1, SK), parameter :: ETX = achar(3, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: End of Text.<br>
87 : character(1, SK), parameter :: EOT = achar(4, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: End of Transmission.<br>
88 : character(1, SK), parameter :: ENQ = achar(5, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Enquiry.<br>
89 : character(1, SK), parameter :: ACK = achar(6, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Acknowledgment.<br>
90 : character(1, SK), parameter :: BEL = achar(7, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Bell (ring character).<br>
91 : character(1, SK), parameter :: BS = achar(8, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Back Space.<br>
92 : character(1, SK), parameter :: HT = achar(9, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Horizontal Tab.<br>
93 : character(1, SK), parameter :: LF = achar(10, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Line Feed (new line character).<br>
94 : character(1, SK), parameter :: VT = achar(11, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Vertical Tab.<br>
95 : character(1, SK), parameter :: FF = achar(12, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Form Feed.<br>
96 : character(1, SK), parameter :: CR = achar(13, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Carriage Return.<br>
97 : character(1, SK), parameter :: SO = achar(14, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Shift Out / X-On.<br>
98 : character(1, SK), parameter :: SI = achar(15, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Shift In / X-Off.<br>
99 : character(1, SK), parameter :: DLE = achar(16, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Data Line Escape.<br>
100 : character(1, SK), parameter :: DC1 = achar(17, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Device Control 1 (oft. XON).<br>
101 : character(1, SK), parameter :: DC2 = achar(18, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Device Control 2.<br>
102 : character(1, SK), parameter :: DC3 = achar(19, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Device Control 3 (oft. XOFF).<br>
103 : character(1, SK), parameter :: DC4 = achar(20, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Device Control 4.<br>
104 : character(1, SK), parameter :: NAK = achar(21, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Negative Acknowledgement.<br>
105 : character(1, SK), parameter :: SYN = achar(22, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Synchronous Idle.<br>
106 : character(1, SK), parameter :: ETB = achar(23, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: End of Transmit Block.<br>
107 : character(1, SK), parameter :: CAN = achar(24, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Cancel.<br>
108 : character(1, SK), parameter :: EM = achar(25, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: End of Medium.<br>
109 : character(1, SK), parameter :: SUB = achar(26, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Substitute.<br>
110 : character(1, SK), parameter :: ESC = achar(27, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Escape.<br>
111 : character(1, SK), parameter :: FS = achar(28, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: File Separator.<br>
112 : character(1, SK), parameter :: GS = achar(29, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Group Separator.<br>
113 : character(1, SK), parameter :: RS = achar(30, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Record Separator.<br>
114 : character(1, SK), parameter :: US = achar(31, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Unit Separator.<br>
115 :
116 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
117 :
118 : ! Windows line terminator.
119 : character(2, SK), parameter :: CRLF = CR//LF !< \public The scalar `character` constant of default kind \SK of length `2` representing ASCII
120 : !! characters Carriage Return and Line Feed that together form the line terminator on Windows systems.<br>
121 :
122 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
123 :
124 : ! ASCII printable characters.
125 :
126 : character(1, SK), parameter :: SPC = achar(32, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Space.<br>
127 : character(1, SK), parameter :: DEL = achar(127, SK) !< \public The scalar `character` constant of default kind \SK of length `1` representing ASCII character: Delete.<br>
128 :
129 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
130 :
131 : !> \brief
132 : !> The constant scalar of type `character` of default kind \SK containing the ASCII uppercase English letters.<br>
133 : character(*, SK), parameter :: ALPHA_UPPER_STR_SK = SK_"ABCDEFGHIJKLMNOPQRSTUVWXYZ"
134 :
135 : !> \brief
136 : !> The constant array of type `character` of default kind \SK containing the uppercase English letters.<br>
137 : character(1, SK), parameter :: ALPHA_UPPER_VEC_SK(*) = [(ALPHA_UPPER_STR_SK(i:i), i = 1, len(ALPHA_UPPER_STR_SK))]
138 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
139 : !DIR$ ATTRIBUTES DLLEXPORT :: ALPHA_UPPER_VEC_SK
140 : #endif
141 :
142 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
143 :
144 : !> \brief
145 : !> The constant scalar of type `character` of default kind \SK containing the ASCII lowercase English letters.<br>
146 : character(*, SK), parameter :: ALPHA_LOWER_STR_SK = SK_"abcdefghijklmnopqrstuvwxyz"
147 :
148 : !> \brief
149 : !> The constant array of type `character` of default kind \SK containing the lowercase English letters.<br>
150 : character(1, SK), parameter :: ALPHA_LOWER_VEC_SK(*) = [(ALPHA_LOWER_STR_SK(i:i), i = 1, len(ALPHA_LOWER_STR_SK))]
151 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
152 : !DIR$ ATTRIBUTES DLLEXPORT :: ALPHA_LOWER_VEC_SK
153 : #endif
154 :
155 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
156 :
157 : !> \brief
158 : !> The constant scalar of type `character` of default kind \SK containing the ASCII uppercase and lowercase English letters.<br>
159 : character(*, SK), parameter :: ALPHA_STR_SK = ALPHA_UPPER_STR_SK//ALPHA_LOWER_STR_SK
160 :
161 : !> \brief
162 : !> The constant array of type `character` of default kind \SK containing the ASCII uppercase and lowercase English letters.<br>
163 : character(1, SK), parameter :: ALPHA_VEC_SK(*) = [ALPHA_UPPER_VEC_SK, ALPHA_LOWER_VEC_SK]
164 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
165 : !DIR$ ATTRIBUTES DLLEXPORT :: ALPHA_VEC_SK
166 : #endif
167 :
168 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
169 :
170 : !> \brief
171 : !> The constant scalar of type `integer` of default kind \IK representing the distance between `A` and `a` in the **processor** collating sequence.<br>
172 : integer(IK) , parameter :: UPPER_MINUS_LOWER_IK = ichar(SK_"A", kind = IK) - ichar(SK_"a", kind = IK)
173 :
174 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
175 :
176 : !> \brief
177 : !> The constant scalar of type `character` of default kind \SK containing the English numbers.<br>
178 : character(*, SK), parameter :: DIGIT_STR_SK = SK_"0123456789"
179 :
180 : !> \brief
181 : !> The constant array of type `character` of default kind \SK containing the English numbers.<br>
182 : character(1, SK), parameter :: DIGIT_VEC_SK(*) = [(DIGIT_STR_SK(i:i), i = 1, len(DIGIT_STR_SK))]
183 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
184 : !DIR$ ATTRIBUTES DLLEXPORT :: DIGIT_VEC_SK
185 : #endif
186 :
187 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
188 :
189 : !> \brief
190 : !> The constant scalar of type `character` of default kind \SK containing the English numbers and alphabets.<br>
191 : character(*, SK), parameter :: ALPHANUM_STR_SK = DIGIT_STR_SK//ALPHA_STR_SK
192 :
193 : !> \brief
194 : !> The constant array of type `character` of default kind \SK containing the English numbers and alphabets.<br>
195 : character(1, SK), parameter :: ALPHANUM_VEC_SK(*) = [DIGIT_VEC_SK, ALPHA_VEC_SK]
196 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
197 : !DIR$ ATTRIBUTES DLLEXPORT :: ALPHANUM_VEC_SK
198 : #endif
199 :
200 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
201 :
202 : !> \brief
203 : !> The constant scalar of type `character` of default kind \SK containing characters that might be used for integer number representation.<br>
204 : character(*, SK), parameter :: INTEGER_STR_SK = DIGIT_STR_SK//SK_"-+"
205 :
206 : !> \brief
207 : !> The constant array of type `character` of default kind \SK containing characters that might be used for integer number representation.<br>
208 : character(1, SK), parameter :: INTEGER_VEC_SK(*) = [(INTEGER_STR_SK(i:i), i = 1, len(INTEGER_STR_SK))]
209 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
210 : !DIR$ ATTRIBUTES DLLEXPORT :: INTEGER_VEC_SK
211 : #endif
212 :
213 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
214 :
215 : !> \brief
216 : !> The constant scalar of type `character` of default kind \SK containing characters that might be used for real number representation.<br>
217 : character(*, SK), parameter :: REAL_STR_SK = DIGIT_STR_SK//SK_".edED"
218 :
219 : !> \brief
220 : !> The constant array of type `character` of default kind \SK containing characters that might be used for real number representation.<br>
221 : character(1, SK), parameter :: REAL_VEC_SK(*) = [(REAL_STR_SK(i:i), i = 1, len(REAL_STR_SK))]
222 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
223 : !DIR$ ATTRIBUTES DLLEXPORT :: REAL_VEC_SK
224 : #endif
225 :
226 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
227 :
228 : !> \brief
229 : !> The constant scalar of type `character` of default kind \SK containing characters that might be used for complex number representation.<br>
230 : character(*, SK), parameter :: COMPLEX_STR_SK = REAL_STR_SK//SK_"(),"
231 :
232 : !> \brief
233 : !> The constant array of type `character` of default kind \SK containing characters that might be used for complex number representation.<br>
234 : character(1, SK), parameter :: COMPLEX_VEC_SK(*) = [(COMPLEX_STR_SK(i:i), i = 1, len(COMPLEX_STR_SK))]
235 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
236 : !DIR$ ATTRIBUTES DLLEXPORT :: COMPLEX_VEC_SK
237 : #endif
238 :
239 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
240 :
241 : !> \brief
242 : !> Generate and return the location of the first occurrence of the whitespace character in the input string, from left to right.<br>
243 : !> Otherwise, return `0` if the input string does not contain a whitespace character.<br>
244 : !>
245 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of default kind \SK.<br>
246 : !>
247 : !> \return
248 : !> `locSpace` : The output scalar or array of the same shape as the input `str` of type `integer` of default kind \IK
249 : !> whose value is the location of the first occurrence of the whitespace character in the input string
250 : !> from the left to the right.<br>
251 : !>
252 : !> \interface{getLocSpace}
253 : !> \code{.F90}
254 : !>
255 : !> use pm_strASCII, only: getLocSpace
256 : !> use pm_kind, only: IK
257 : !> integer(IK) :: locSpace
258 : !>
259 : !> locSpace = getLocSpace(str)
260 : !>
261 : !> \endcode
262 : !>
263 : !> \pure
264 : !>
265 : !> \elemental
266 : !>
267 : !> \remark
268 : !> This procedure exists primarily to facilitate coding of other procedures in this module.<br>
269 : !> Other algorithms in this library listed below can provide more general solutions to the problem solved by this procedure.<br>
270 : !>
271 : !> \see
272 : !> [getLocNonSpace](@ref pm_strASCII::getLocNonSpace)<br>
273 : !> [setLoc](@ref pm_arrayFind::setLoc)<br>
274 : !> [getLoc](@ref pm_arrayFind::getLoc)<br>
275 : !> [getBin](@ref pm_arraySearch::getBin)<br>
276 : !>
277 : !> \example{getLocSpace}
278 : !> \include{lineno} example/pm_strASCII/getLocSpace/main.F90
279 : !> \compilef{getLocSpace}
280 : !> \output{getLocSpace}
281 : !> \include{lineno} example/pm_strASCII/getLocSpace/main.out.F90
282 : !>
283 : !> \test
284 : !> [test_pm_strASCII](@ref test_pm_strASCII)
285 : !>
286 : !> \finmain
287 : !>
288 : !> \author
289 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
290 : interface getLocSpace
291 :
292 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
293 :
294 : #if SK5_ENABLED
295 : pure elemental module function getLocSpace_SK5(str) result(locSpace)
296 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
297 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocSpace_SK5
298 : #endif
299 : use pm_kind, only: SKC => SK5
300 : character(*,SKC) , intent(in) :: str
301 : integer(IK) :: locSpace
302 : end function
303 : #endif
304 :
305 : #if SK4_ENABLED
306 : pure elemental module function getLocSpace_SK4(str) result(locSpace)
307 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
308 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocSpace_SK4
309 : #endif
310 : use pm_kind, only: SKC => SK4
311 : character(*,SKC) , intent(in) :: str
312 : integer(IK) :: locSpace
313 : end function
314 : #endif
315 :
316 : #if SK3_ENABLED
317 : pure elemental module function getLocSpace_SK3(str) result(locSpace)
318 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
319 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocSpace_SK3
320 : #endif
321 : use pm_kind, only: SKC => SK3
322 : character(*,SKC) , intent(in) :: str
323 : integer(IK) :: locSpace
324 : end function
325 : #endif
326 :
327 : #if SK2_ENABLED
328 : pure elemental module function getLocSpace_SK2(str) result(locSpace)
329 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
330 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocSpace_SK2
331 : #endif
332 : use pm_kind, only: SKC => SK2
333 : character(*,SKC) , intent(in) :: str
334 : integer(IK) :: locSpace
335 : end function
336 : #endif
337 :
338 : #if SK1_ENABLED
339 : pure elemental module function getLocSpace_SK1(str) result(locSpace)
340 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
341 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocSpace_SK1
342 : #endif
343 : use pm_kind, only: SKC => SK1
344 : character(*,SKC) , intent(in) :: str
345 : integer(IK) :: locSpace
346 : end function
347 : #endif
348 :
349 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
350 :
351 : end interface
352 :
353 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
354 :
355 : !> \brief
356 : !> Generate and return the location of the first occurrence of a non-whitespace character in the input string, from left to right.<br>
357 : !> Otherwise, return `0` if the input string is all whitespace characters.<br>
358 : !>
359 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of default kind \SK.<br>
360 : !>
361 : !> \return
362 : !> `locNonSpace` : The output scalar or array of the same shape as the input `str` of type `integer` of default kind \IK
363 : !> whose value is the location of the first occurrence of the whitespace character in the input string
364 : !> from the left to the right.<br>
365 : !>
366 : !> \interface{getLocNonSpace}
367 : !> \code{.F90}
368 : !>
369 : !> use pm_strASCII, only: getLocNonSpace
370 : !> use pm_kind, only: IK
371 : !> integer(IK) :: locNonSpace
372 : !>
373 : !> locNonSpace = getLocNonSpace(str)
374 : !>
375 : !> \endcode
376 : !>
377 : !> \pure
378 : !>
379 : !> \elemental
380 : !>
381 : !> \remark
382 : !> This procedure exists primarily to facilitate coding of other procedures in this module.<br>
383 : !> Other algorithms in this library listed below can provide more general solutions to the problem solved by this procedure.<br>
384 : !>
385 : !> \see
386 : !> [getLocNonSpace](@ref pm_strASCII::getLocNonSpace)<br>
387 : !> [setLoc](@ref pm_arrayFind::setLoc)<br>
388 : !> [getLoc](@ref pm_arrayFind::getLoc)<br>
389 : !> [getBin](@ref pm_arraySearch::getBin)<br>
390 : !>
391 : !> \example{getLocNonSpace}
392 : !> \include{lineno} example/pm_strASCII/getLocNonSpace/main.F90
393 : !> \compilef{getLocNonSpace}
394 : !> \output{getLocNonSpace}
395 : !> \include{lineno} example/pm_strASCII/getLocNonSpace/main.out.F90
396 : !>
397 : !> \test
398 : !> [test_pm_strASCII](@ref test_pm_strASCII)
399 : !>
400 : !> \finmain
401 : !>
402 : !> \author
403 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
404 : interface getLocNonSpace
405 :
406 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
407 :
408 : #if SK5_ENABLED
409 : pure elemental module function getLocNonSpace_SK5(str) result(locNonSpace)
410 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
411 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocNonSpace_SK5
412 : #endif
413 : use pm_kind, only: SKC => SK5
414 : character(*,SKC) , intent(in) :: str
415 : integer(IK) :: locNonSpace
416 : end function
417 : #endif
418 :
419 : #if SK4_ENABLED
420 : pure elemental module function getLocNonSpace_SK4(str) result(locNonSpace)
421 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
422 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocNonSpace_SK4
423 : #endif
424 : use pm_kind, only: SKC => SK4
425 : character(*,SKC) , intent(in) :: str
426 : integer(IK) :: locNonSpace
427 : end function
428 : #endif
429 :
430 : #if SK3_ENABLED
431 : pure elemental module function getLocNonSpace_SK3(str) result(locNonSpace)
432 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
433 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocNonSpace_SK3
434 : #endif
435 : use pm_kind, only: SKC => SK3
436 : character(*,SKC) , intent(in) :: str
437 : integer(IK) :: locNonSpace
438 : end function
439 : #endif
440 :
441 : #if SK2_ENABLED
442 : pure elemental module function getLocNonSpace_SK2(str) result(locNonSpace)
443 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
444 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocNonSpace_SK2
445 : #endif
446 : use pm_kind, only: SKC => SK2
447 : character(*,SKC) , intent(in) :: str
448 : integer(IK) :: locNonSpace
449 : end function
450 : #endif
451 :
452 : #if SK1_ENABLED
453 : pure elemental module function getLocNonSpace_SK1(str) result(locNonSpace)
454 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
455 : !DEC$ ATTRIBUTES DLLEXPORT :: getLocNonSpace_SK1
456 : #endif
457 : use pm_kind, only: SKC => SK1
458 : character(*,SKC) , intent(in) :: str
459 : integer(IK) :: locNonSpace
460 : end function
461 : #endif
462 :
463 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
464 :
465 : end interface
466 :
467 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
468 :
469 : !> \brief
470 : !> Generate and return `.true.` if the input character of length `1` is a digit as in [DIGIT_VEC_SK](@ref pm_strASCII::DIGIT_VEC_SK).<br>
471 : !>
472 : !> \param[in] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of length `1`.<br>
473 : !>
474 : !> \return
475 : !> `charIsDigit` : The output scalar or array of the same shape as the input `chr` of type `logical` of default kind \LK
476 : !> whose value is `.true.` corresponding to each element of the input `chr` if the element is a digit,
477 : !> otherwise it is `.false.`.<br>
478 : !>
479 : !> \interface{isCharDigit}
480 : !> \code{.F90}
481 : !>
482 : !> use pm_strASCII, only: isCharDigit
483 : !> use pm_kind, only: LK
484 : !> logical(LK) :: charIsDigit
485 : !>
486 : !> charIsDigit = isCharDigit(chr)
487 : !>
488 : !> \endcode
489 : !>
490 : !> \pure
491 : !>
492 : !> \elemental
493 : !>
494 : !> \see
495 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
496 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
497 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
498 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
499 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
500 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
501 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
502 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
503 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
504 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
505 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
506 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
507 : !>
508 : !> \example{isCharDigit}
509 : !> \include{lineno} example/pm_strASCII/isCharDigit/main.F90
510 : !> \compilef{isCharDigit}
511 : !> \output{isCharDigit}
512 : !> \include{lineno} example/pm_strASCII/isCharDigit/main.out.F90
513 : !>
514 : !> \test
515 : !> [test_pm_strASCII](@ref test_pm_strASCII)
516 : !>
517 : !> \finmain
518 : !>
519 : !> \author
520 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
521 : interface isCharDigit
522 :
523 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
524 :
525 : #if SK5_ENABLED
526 : pure elemental module function isCharDigit_SK5(chr) result(charIsDigit)
527 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
528 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharDigit_SK5
529 : #endif
530 : use pm_kind, only: SKC => SK5
531 : character(1,SKC) , intent(in) :: chr
532 : logical(LK) :: charIsDigit
533 : end function
534 : #endif
535 :
536 : #if SK4_ENABLED
537 : pure elemental module function isCharDigit_SK4(chr) result(charIsDigit)
538 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
539 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharDigit_SK4
540 : #endif
541 : use pm_kind, only: SKC => SK4
542 : character(1,SKC) , intent(in) :: chr
543 : logical(LK) :: charIsDigit
544 : end function
545 : #endif
546 :
547 : #if SK3_ENABLED
548 : pure elemental module function isCharDigit_SK3(chr) result(charIsDigit)
549 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
550 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharDigit_SK3
551 : #endif
552 : use pm_kind, only: SKC => SK3
553 : character(1,SKC) , intent(in) :: chr
554 : logical(LK) :: charIsDigit
555 : end function
556 : #endif
557 :
558 : #if SK2_ENABLED
559 : pure elemental module function isCharDigit_SK2(chr) result(charIsDigit)
560 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
561 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharDigit_SK2
562 : #endif
563 : use pm_kind, only: SKC => SK2
564 : character(1,SKC) , intent(in) :: chr
565 : logical(LK) :: charIsDigit
566 : end function
567 : #endif
568 :
569 : #if SK1_ENABLED
570 : pure elemental module function isCharDigit_SK1(chr) result(charIsDigit)
571 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
572 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharDigit_SK1
573 : #endif
574 : use pm_kind, only: SKC => SK1
575 : character(1,SKC) , intent(in) :: chr
576 : logical(LK) :: charIsDigit
577 : end function
578 : #endif
579 :
580 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
581 :
582 : end interface
583 :
584 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
585 :
586 : !> \brief
587 : !> Generate and return `.true.` if **all characters** of the input string are numeric (digits as in [DIGIT_VEC_SK](@ref pm_strASCII::DIGIT_VEC_SK)).<br>
588 : !>
589 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
590 : !>
591 : !> \return
592 : !> `strIsDigitAll` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
593 : !> whose value is `.true.` if **all** characters of the corresponding element of `str` are numeric,
594 : !> otherwise it is `.false.`.<br>
595 : !>
596 : !> \interface{isStrDigitAll}
597 : !> \code{.F90}
598 : !>
599 : !> use pm_strASCII, only: isStrDigitAll
600 : !> use pm_kind, only: LK
601 : !> logical(LK) :: strIsDigit
602 : !>
603 : !> strIsDigit = isStrDigitAll(str)
604 : !>
605 : !> \endcode
606 : !>
607 : !> \pure
608 : !>
609 : !> \elemental
610 : !>
611 : !> \note
612 : !> The functionality of this interface can be also replicated by [isStrDigit](@ref pm_strASCII::isStrDigit),
613 : !> \code{.F90}
614 : !>
615 : !> character(10) :: str
616 : !>
617 : !> isStrDigitAll(str) == all(isStrDigit(str))
618 : !>
619 : !> \endcode
620 : !> although this generic interface is potentially faster than [isStrDigit](@ref pm_strASCII::isStrDigit).<br>
621 : !>
622 : !> \see
623 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
624 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
625 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
626 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
627 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
628 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
629 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
630 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
631 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
632 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
633 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
634 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
635 : !>
636 : !> \example{isStrDigitAll}
637 : !> \include{lineno} example/pm_strASCII/isStrDigitAll/main.F90
638 : !> \compilef{isStrDigitAll}
639 : !> \output{isStrDigitAll}
640 : !> \include{lineno} example/pm_strASCII/isStrDigitAll/main.out.F90
641 : !>
642 : !> \test
643 : !> [test_pm_strASCII](@ref test_pm_strASCII)
644 : !>
645 : !> \finmain
646 : !>
647 : !> \author
648 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
649 : interface isStrDigitAll
650 :
651 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
652 :
653 : #if SK5_ENABLED
654 : pure elemental module function isStrDigitAll_SK5(str) result(strIsDigitAll)
655 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
656 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAll_SK5
657 : #endif
658 : use pm_kind, only: SKC => SK5
659 : character(*,SKC) , intent(in) :: str
660 : logical(LK) :: strIsDigitAll
661 : end function
662 : #endif
663 :
664 : #if SK4_ENABLED
665 : pure elemental module function isStrDigitAll_SK4(str) result(strIsDigitAll)
666 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
667 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAll_SK4
668 : #endif
669 : use pm_kind, only: SKC => SK4
670 : character(*,SKC) , intent(in) :: str
671 : logical(LK) :: strIsDigitAll
672 : end function
673 : #endif
674 :
675 : #if SK3_ENABLED
676 : pure elemental module function isStrDigitAll_SK3(str) result(strIsDigitAll)
677 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
678 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAll_SK3
679 : #endif
680 : use pm_kind, only: SKC => SK3
681 : character(*,SKC) , intent(in) :: str
682 : logical(LK) :: strIsDigitAll
683 : end function
684 : #endif
685 :
686 : #if SK2_ENABLED
687 : pure elemental module function isStrDigitAll_SK2(str) result(strIsDigitAll)
688 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
689 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAll_SK2
690 : #endif
691 : use pm_kind, only: SKC => SK2
692 : character(*,SKC) , intent(in) :: str
693 : logical(LK) :: strIsDigitAll
694 : end function
695 : #endif
696 :
697 : #if SK1_ENABLED
698 : pure elemental module function isStrDigitAll_SK1(str) result(strIsDigitAll)
699 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
700 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAll_SK1
701 : #endif
702 : use pm_kind, only: SKC => SK1
703 : character(*,SKC) , intent(in) :: str
704 : logical(LK) :: strIsDigitAll
705 : end function
706 : #endif
707 :
708 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
709 :
710 : end interface
711 :
712 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
713 :
714 : !> \brief
715 : !> Generate and return `.true.` if **any character** of the input string is numeric (digits as in [DIGIT_VEC_SK](@ref pm_strASCII::DIGIT_VEC_SK)).<br>
716 : !>
717 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
718 : !>
719 : !> \return
720 : !> `strIsDigitAny` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
721 : !> whose value is `.true.` if **any character** of the corresponding element of `str` is numeric,
722 : !> otherwise it is `.false.`.<br>
723 : !>
724 : !> \interface{isStrDigitAny}
725 : !> \code{.F90}
726 : !>
727 : !> use pm_strASCII, only: isStrDigitAny
728 : !> use pm_kind, only: LK
729 : !> logical(LK) :: strIsDigitAny
730 : !>
731 : !> strIsDigitAny = isStrDigitAny(str)
732 : !>
733 : !> \endcode
734 : !>
735 : !> \pure
736 : !>
737 : !> \elemental
738 : !>
739 : !> \note
740 : !> The functionality of this interface can be also replicated by [isStrDigit](@ref pm_strASCII::isStrDigit),
741 : !> \code{.F90}
742 : !>
743 : !> character(10) :: str
744 : !>
745 : !> isStrDigitAny(str) == any(isStrDigit(str))
746 : !>
747 : !> \endcode
748 : !> although this generic interface is potentially faster than [isStrDigit](@ref pm_strASCII::isStrDigit).<br>
749 : !>
750 : !> \see
751 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
752 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
753 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
754 : !> [isStrDigitAny](@ref pm_strASCII::isStrDigitAny)<br>
755 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
756 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
757 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
758 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
759 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
760 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
761 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
762 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
763 : !>
764 : !> \example{isStrDigitAny}
765 : !> \include{lineno} example/pm_strASCII/isStrDigitAny/main.F90
766 : !> \compilef{isStrDigitAny}
767 : !> \output{isStrDigitAny}
768 : !> \include{lineno} example/pm_strASCII/isStrDigitAny/main.out.F90
769 : !>
770 : !> \test
771 : !> [test_pm_strASCII](@ref test_pm_strASCII)
772 : !>
773 : !> \finmain
774 : !>
775 : !> \author
776 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
777 : interface isStrDigitAny
778 :
779 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
780 :
781 : #if SK5_ENABLED
782 : pure elemental module function isStrDigitAny_SK5(str) result(strIsDigitAny)
783 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
784 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAny_SK5
785 : #endif
786 : use pm_kind, only: SKC => SK5
787 : character(*,SKC) , intent(in) :: str
788 : logical(LK) :: strIsDigitAny
789 : end function
790 : #endif
791 :
792 : #if SK4_ENABLED
793 : pure elemental module function isStrDigitAny_SK4(str) result(strIsDigitAny)
794 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
795 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAny_SK4
796 : #endif
797 : use pm_kind, only: SKC => SK4
798 : character(*,SKC) , intent(in) :: str
799 : logical(LK) :: strIsDigitAny
800 : end function
801 : #endif
802 :
803 : #if SK3_ENABLED
804 : pure elemental module function isStrDigitAny_SK3(str) result(strIsDigitAny)
805 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
806 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAny_SK3
807 : #endif
808 : use pm_kind, only: SKC => SK3
809 : character(*,SKC) , intent(in) :: str
810 : logical(LK) :: strIsDigitAny
811 : end function
812 : #endif
813 :
814 : #if SK2_ENABLED
815 : pure elemental module function isStrDigitAny_SK2(str) result(strIsDigitAny)
816 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
817 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAny_SK2
818 : #endif
819 : use pm_kind, only: SKC => SK2
820 : character(*,SKC) , intent(in) :: str
821 : logical(LK) :: strIsDigitAny
822 : end function
823 : #endif
824 :
825 : #if SK1_ENABLED
826 : pure elemental module function isStrDigitAny_SK1(str) result(strIsDigitAny)
827 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
828 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigitAny_SK1
829 : #endif
830 : use pm_kind, only: SKC => SK1
831 : character(*,SKC) , intent(in) :: str
832 : logical(LK) :: strIsDigitAny
833 : end function
834 : #endif
835 :
836 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
837 :
838 : end interface
839 :
840 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
841 :
842 : !> \brief
843 : !> Generate and return a vector of logical values of the same size as the length of the input scalar string `str`, whose elements
844 : !> are `.true.` <b>if and only if</b> the corresponding character in the input `str` is numeric (digits as in [DIGIT_VEC_SK](@ref pm_strASCII::DIGIT_VEC_SK)).<br>
845 : !>
846 : !> \param[in] str : The input scalar of type `character` of kind \SKALL.<br>
847 : !>
848 : !> \return
849 : !> `StrIsNumeric` : The output array of rank `1` of the same size as the length of the input scalar `str`, of type `logical` of default kind \LK,
850 : !> whose elements are `.true.` <b>if and only if</b> the corresponding character in the input `str` is numeric,
851 : !> otherwise it is `.false.`.<br>
852 : !>
853 : !> \interface{isStrDigit}
854 : !> \code{.F90}
855 : !>
856 : !> use pm_strASCII, only: isStrDigit
857 : !> use pm_kind, only: LK
858 : !> logical(LK) :: StrIsNumeric(len(str,IK))
859 : !>
860 : !> StrIsNumeric = isStrDigit(str)
861 : !>
862 : !> \endcode
863 : !>
864 : !> \pure
865 : !>
866 : !> \see
867 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
868 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
869 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
870 : !> [isStrDigit](@ref pm_strASCII::isStrDigit)<br>
871 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
872 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
873 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
874 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
875 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
876 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
877 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
878 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
879 : !>
880 : !> \example{isStrDigit}
881 : !> \include{lineno} example/pm_strASCII/isStrDigit/main.F90
882 : !> \compilef{isStrDigit}
883 : !> \output{isStrDigit}
884 : !> \include{lineno} example/pm_strASCII/isStrDigit/main.out.F90
885 : !>
886 : !> \test
887 : !> [test_pm_strASCII](@ref test_pm_strASCII)
888 : !>
889 : !> \finmain
890 : !>
891 : !> \author
892 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
893 : interface isStrDigit
894 :
895 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
896 :
897 : #if SK5_ENABLED
898 : pure module function isStrDigit_SK5(str) result(StrIsNumeric)
899 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
900 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigit_SK5
901 : #endif
902 : use pm_kind, only: SKC => SK5
903 : character(*,SKC) , intent(in) :: str
904 : logical(LK) :: StrIsNumeric(len(str,IK))
905 : end function
906 : #endif
907 :
908 : #if SK4_ENABLED
909 : pure module function isStrDigit_SK4(str) result(StrIsNumeric)
910 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
911 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigit_SK4
912 : #endif
913 : use pm_kind, only: SKC => SK4
914 : character(*,SKC) , intent(in) :: str
915 : logical(LK) :: StrIsNumeric(len(str,IK))
916 : end function
917 : #endif
918 :
919 : #if SK3_ENABLED
920 : pure module function isStrDigit_SK3(str) result(StrIsNumeric)
921 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
922 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigit_SK3
923 : #endif
924 : use pm_kind, only: SKC => SK3
925 : character(*,SKC) , intent(in) :: str
926 : logical(LK) :: StrIsNumeric(len(str,IK))
927 : end function
928 : #endif
929 :
930 : #if SK2_ENABLED
931 : pure module function isStrDigit_SK2(str) result(StrIsNumeric)
932 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
933 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigit_SK2
934 : #endif
935 : use pm_kind, only: SKC => SK2
936 : character(*,SKC) , intent(in) :: str
937 : logical(LK) :: StrIsNumeric(len(str,IK))
938 : end function
939 : #endif
940 :
941 : #if SK1_ENABLED
942 : pure module function isStrDigit_SK1(str) result(StrIsNumeric)
943 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
944 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrDigit_SK1
945 : #endif
946 : use pm_kind, only: SKC => SK1
947 : character(*,SKC) , intent(in) :: str
948 : logical(LK) :: StrIsNumeric(len(str,IK))
949 : end function
950 : #endif
951 :
952 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
953 :
954 : end interface
955 :
956 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
957 :
958 : !> \brief
959 : !> Generate and return `.true.` if all characters of the input string collectively represent a real number.<br>
960 : !>
961 : !> \details
962 : !> The characters used in the representation of a real number are given by [REAL_VEC_SK](@ref pm_strASCII::REAL_VEC_SK)).<br>
963 : !> The `real` string must contain only these characters and must collectively represent a meaningful real number.<br>
964 : !>
965 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
966 : !>
967 : !> \return
968 : !> `strIsReal` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
969 : !> whose value is `.true.` corresponding to each element of the input `str` if the element is a real
970 : !> number, otherwise it is `.false.`.<br>
971 : !>
972 : !> \interface{isStrReal}
973 : !> \code{.F90}
974 : !>
975 : !> use pm_strASCII, only: isStrReal
976 : !> use pm_kind, only: LK
977 : !> logical(LK) :: strIsReal
978 : !>
979 : !> strIsReal = isStrReal(str)
980 : !>
981 : !> \endcode
982 : !>
983 : !> \warning
984 : !> This procedure is sensitive to the presence of white-space characters in the string, in which case the output is `.false.`.<br>
985 : !> The must not exist any white-space within the real number or at the beginning or the end of the string.<br>
986 : !> If there is the possibility for any trailing or preceding white-space characters in the string,
987 : !> pass `trim(adjustl(str))` as the input argument instead.<br>
988 : !>
989 : !> \pure
990 : !>
991 : !> \elemental
992 : !>
993 : !> \see
994 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
995 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
996 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
997 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
998 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
999 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1000 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1001 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1002 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
1003 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
1004 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1005 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1006 : !>
1007 : !> \example{isStrReal}
1008 : !> \include{lineno} example/pm_strASCII/isStrReal/main.F90
1009 : !> \compilef{isStrReal}
1010 : !> \output{isStrReal}
1011 : !> \include{lineno} example/pm_strASCII/isStrReal/main.out.F90
1012 : !>
1013 : !> \test
1014 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1015 : !>
1016 : !> \finmain
1017 : !>
1018 : !> \author
1019 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1020 : interface isStrReal
1021 :
1022 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1023 :
1024 : #if SK5_ENABLED
1025 : pure elemental module function isStrReal_SK5(str) result(strIsReal)
1026 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1027 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrReal_SK5
1028 : #endif
1029 : use pm_kind, only: SKC => SK5
1030 : character(*,SKC) , intent(in) :: str
1031 : logical(LK) :: strIsReal
1032 : end function
1033 : #endif
1034 :
1035 : #if SK4_ENABLED
1036 : pure elemental module function isStrReal_SK4(str) result(strIsReal)
1037 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1038 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrReal_SK4
1039 : #endif
1040 : use pm_kind, only: SKC => SK4
1041 : character(*,SKC) , intent(in) :: str
1042 : logical(LK) :: strIsReal
1043 : end function
1044 : #endif
1045 :
1046 : #if SK3_ENABLED
1047 : pure elemental module function isStrReal_SK3(str) result(strIsReal)
1048 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1049 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrReal_SK3
1050 : #endif
1051 : use pm_kind, only: SKC => SK3
1052 : character(*,SKC) , intent(in) :: str
1053 : logical(LK) :: strIsReal
1054 : end function
1055 : #endif
1056 :
1057 : #if SK2_ENABLED
1058 : pure elemental module function isStrReal_SK2(str) result(strIsReal)
1059 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1060 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrReal_SK2
1061 : #endif
1062 : use pm_kind, only: SKC => SK2
1063 : character(*,SKC) , intent(in) :: str
1064 : logical(LK) :: strIsReal
1065 : end function
1066 : #endif
1067 :
1068 : #if SK1_ENABLED
1069 : pure elemental module function isStrReal_SK1(str) result(strIsReal)
1070 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1071 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrReal_SK1
1072 : #endif
1073 : use pm_kind, only: SKC => SK1
1074 : character(*,SKC) , intent(in) :: str
1075 : logical(LK) :: strIsReal
1076 : end function
1077 : #endif
1078 :
1079 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1080 :
1081 : end interface
1082 :
1083 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1084 :
1085 : !> \brief
1086 : !> Generate and return `.true.` if all characters of the input string collectively represent a complex number.<br>
1087 : !>
1088 : !> \details
1089 : !> The characters used in the representation of a complex number are given by [COMPLEX_VEC_SK](@ref pm_strASCII::COMPLEX_VEC_SK)).<br>
1090 : !> The `complex` string must contain only these characters and must collectively represent a meaningful complex number.<br>
1091 : !>
1092 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
1093 : !>
1094 : !> \return
1095 : !> `strIsComplex` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
1096 : !> whose value is `.true.` corresponding to each element of the input `str` if the element is a complex
1097 : !> number, otherwise it is `.false.`.<br>
1098 : !>
1099 : !> \interface{isStrComplex}
1100 : !> \code{.F90}
1101 : !>
1102 : !> use pm_strASCII, only: isStrComplex
1103 : !> use pm_kind, only: LK
1104 : !> logical(LK) :: strIsComplex
1105 : !>
1106 : !> strIsComplex = isStrComplex(str)
1107 : !>
1108 : !> \endcode
1109 : !>
1110 : !> \pure
1111 : !>
1112 : !> \elemental
1113 : !>
1114 : !> \see
1115 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1116 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1117 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1118 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1119 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1120 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1121 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1122 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1123 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
1124 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
1125 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1126 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1127 : !>
1128 : !> \example{isStrComplex}
1129 : !> \include{lineno} example/pm_strASCII/isStrComplex/main.F90
1130 : !> \compilef{isStrComplex}
1131 : !> \output{isStrComplex}
1132 : !> \include{lineno} example/pm_strASCII/isStrComplex/main.out.F90
1133 : !>
1134 : !> \test
1135 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1136 : !>
1137 : !> \finmain
1138 : !>
1139 : !> \author
1140 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1141 : interface isStrComplex
1142 :
1143 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1144 :
1145 : #if SK5_ENABLED
1146 : pure elemental module function isStrComplex_SK5(str) result(strIsComplex)
1147 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1148 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrComplex_SK5
1149 : #endif
1150 : use pm_kind, only: SKC => SK5
1151 : character(*,SKC) , intent(in) :: str
1152 : logical(LK) :: strIsComplex
1153 : end function
1154 : #endif
1155 :
1156 : #if SK4_ENABLED
1157 : pure elemental module function isStrComplex_SK4(str) result(strIsComplex)
1158 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1159 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrComplex_SK4
1160 : #endif
1161 : use pm_kind, only: SKC => SK4
1162 : character(*,SKC) , intent(in) :: str
1163 : logical(LK) :: strIsComplex
1164 : end function
1165 : #endif
1166 :
1167 : #if SK3_ENABLED
1168 : pure elemental module function isStrComplex_SK3(str) result(strIsComplex)
1169 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1170 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrComplex_SK3
1171 : #endif
1172 : use pm_kind, only: SKC => SK3
1173 : character(*,SKC) , intent(in) :: str
1174 : logical(LK) :: strIsComplex
1175 : end function
1176 : #endif
1177 :
1178 : #if SK2_ENABLED
1179 : pure elemental module function isStrComplex_SK2(str) result(strIsComplex)
1180 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1181 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrComplex_SK2
1182 : #endif
1183 : use pm_kind, only: SKC => SK2
1184 : character(*,SKC) , intent(in) :: str
1185 : logical(LK) :: strIsComplex
1186 : end function
1187 : #endif
1188 :
1189 : #if SK1_ENABLED
1190 : pure elemental module function isStrComplex_SK1(str) result(strIsComplex)
1191 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1192 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrComplex_SK1
1193 : #endif
1194 : use pm_kind, only: SKC => SK1
1195 : character(*,SKC) , intent(in) :: str
1196 : logical(LK) :: strIsComplex
1197 : end function
1198 : #endif
1199 :
1200 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1201 :
1202 : end interface
1203 :
1204 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1205 :
1206 : !> \brief
1207 : !> Generate and return `.true.` if all characters of the input string collectively represent an integer.<br>
1208 : !>
1209 : !> \details
1210 : !> The characters used in the representation of an integer number are given by [INTEGER_VEC_SK](@ref pm_strASCII::INTEGER_VEC_SK)).<br>
1211 : !> The `integer` string must contain only these characters and must collectively represent a meaningful integer number.<br>
1212 : !>
1213 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
1214 : !>
1215 : !> \return
1216 : !> `strIsInteger` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
1217 : !> whose value is `.true.` corresponding to each element of the input `str` if the element is an integer
1218 : !> number, otherwise it is `.false.`.<br>
1219 : !>
1220 : !> \interface{isStrInteger}
1221 : !> \code{.F90}
1222 : !>
1223 : !> use pm_kind, only: LK
1224 : !> use pm_strASCII, only: isStrInteger
1225 : !> logical(LK) :: strIsInteger
1226 : !>
1227 : !> strIsInteger = isStrInteger(str)
1228 : !>
1229 : !> \endcode
1230 : !>
1231 : !> \pure
1232 : !>
1233 : !> \elemental
1234 : !>
1235 : !> \see
1236 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1237 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1238 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1239 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1240 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1241 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1242 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1243 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1244 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
1245 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
1246 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1247 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1248 : !>
1249 : !> \example{isStrInteger}
1250 : !> \include{lineno} example/pm_strASCII/isStrInteger/main.F90
1251 : !> \compilef{isStrInteger}
1252 : !> \output{isStrInteger}
1253 : !> \include{lineno} example/pm_strASCII/isStrInteger/main.out.F90
1254 : !>
1255 : !> \test
1256 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1257 : !>
1258 : !> \finmain
1259 : !>
1260 : !> \author
1261 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1262 : interface isStrInteger
1263 :
1264 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1265 :
1266 : #if SK5_ENABLED
1267 : pure elemental module function isStrInteger_SK5(str) result(strIsInteger)
1268 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1269 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrInteger_SK5
1270 : #endif
1271 : use pm_kind, only: SKC => SK5
1272 : character(*,SKC) , intent(in) :: str
1273 : logical(LK) :: strIsInteger
1274 : end function
1275 : #endif
1276 :
1277 : #if SK4_ENABLED
1278 : pure elemental module function isStrInteger_SK4(str) result(strIsInteger)
1279 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1280 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrInteger_SK4
1281 : #endif
1282 : use pm_kind, only: SKC => SK4
1283 : character(*,SKC) , intent(in) :: str
1284 : logical(LK) :: strIsInteger
1285 : end function
1286 : #endif
1287 :
1288 : #if SK3_ENABLED
1289 : pure elemental module function isStrInteger_SK3(str) result(strIsInteger)
1290 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1291 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrInteger_SK3
1292 : #endif
1293 : use pm_kind, only: SKC => SK3
1294 : character(*,SKC) , intent(in) :: str
1295 : logical(LK) :: strIsInteger
1296 : end function
1297 : #endif
1298 :
1299 : #if SK2_ENABLED
1300 : pure elemental module function isStrInteger_SK2(str) result(strIsInteger)
1301 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1302 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrInteger_SK2
1303 : #endif
1304 : use pm_kind, only: SKC => SK2
1305 : character(*,SKC) , intent(in) :: str
1306 : logical(LK) :: strIsInteger
1307 : end function
1308 : #endif
1309 :
1310 : #if SK1_ENABLED
1311 : pure elemental module function isStrInteger_SK1(str) result(strIsInteger)
1312 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1313 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrInteger_SK1
1314 : #endif
1315 : use pm_kind, only: SKC => SK1
1316 : character(*,SKC) , intent(in) :: str
1317 : logical(LK) :: strIsInteger
1318 : end function
1319 : #endif
1320 :
1321 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1322 :
1323 : end interface
1324 :
1325 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1326 :
1327 : !> \brief
1328 : !> Generate and return `.true.` if the input string collectively represents an integer, a real, or a complex number.<br>
1329 : !>
1330 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
1331 : !>
1332 : !> \return
1333 : !> `strIsNumber` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
1334 : !> whose value is `.true.` corresponding to each element of the input `str` if the element is an integer,
1335 : !> a real, or a complex number, otherwise it is `.false.`.<br>
1336 : !>
1337 : !> \interface{isStrNumber}
1338 : !> \code{.F90}
1339 : !>
1340 : !> use pm_strASCII, only: isStrNumber
1341 : !> use pm_kind, only: LK
1342 : !> logical(LK) :: strIsNumber
1343 : !>
1344 : !> strIsNumber = isStrNumber(str)
1345 : !>
1346 : !> \endcode
1347 : !>
1348 : !> \pure
1349 : !>
1350 : !> \elemental
1351 : !>
1352 : !> \see
1353 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1354 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1355 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1356 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1357 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1358 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1359 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1360 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1361 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
1362 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
1363 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1364 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1365 : !>
1366 : !> \example{isStrNumber}
1367 : !> \include{lineno} example/pm_strASCII/isStrNumber/main.F90
1368 : !> \compilef{isStrNumber}
1369 : !> \output{isStrNumber}
1370 : !> \include{lineno} example/pm_strASCII/isStrNumber/main.out.F90
1371 : !>
1372 : !> \test
1373 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1374 : !>
1375 : !> \finmain
1376 : !>
1377 : !> \author
1378 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1379 : interface isStrNumber
1380 :
1381 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1382 :
1383 : #if SK5_ENABLED
1384 : pure elemental module function isStrNumber_SK5(str) result(strIsNumber)
1385 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1386 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrNumber_SK5
1387 : #endif
1388 : use pm_kind, only: SKC => SK5
1389 : character(*,SKC) , intent(in) :: str
1390 : logical(LK) :: strIsNumber
1391 : end function
1392 : #endif
1393 :
1394 : #if SK4_ENABLED
1395 : pure elemental module function isStrNumber_SK4(str) result(strIsNumber)
1396 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1397 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrNumber_SK4
1398 : #endif
1399 : use pm_kind, only: SKC => SK4
1400 : character(*,SKC) , intent(in) :: str
1401 : logical(LK) :: strIsNumber
1402 : end function
1403 : #endif
1404 :
1405 : #if SK3_ENABLED
1406 : pure elemental module function isStrNumber_SK3(str) result(strIsNumber)
1407 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1408 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrNumber_SK3
1409 : #endif
1410 : use pm_kind, only: SKC => SK3
1411 : character(*,SKC) , intent(in) :: str
1412 : logical(LK) :: strIsNumber
1413 : end function
1414 : #endif
1415 :
1416 : #if SK2_ENABLED
1417 : pure elemental module function isStrNumber_SK2(str) result(strIsNumber)
1418 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1419 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrNumber_SK2
1420 : #endif
1421 : use pm_kind, only: SKC => SK2
1422 : character(*,SKC) , intent(in) :: str
1423 : logical(LK) :: strIsNumber
1424 : end function
1425 : #endif
1426 :
1427 : #if SK1_ENABLED
1428 : pure elemental module function isStrNumber_SK1(str) result(strIsNumber)
1429 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1430 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrNumber_SK1
1431 : #endif
1432 : use pm_kind, only: SKC => SK1
1433 : character(*,SKC) , intent(in) :: str
1434 : logical(LK) :: strIsNumber
1435 : end function
1436 : #endif
1437 :
1438 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1439 :
1440 : end interface
1441 :
1442 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1443 :
1444 : !> \brief
1445 : !> Generate and return `.true.` if the input single character contains an uppercase English alphabet [ALPHA_UPPER_VEC_SK](@ref ALPHA_UPPER_VEC_SK).<br>
1446 : !>
1447 : !> \param[in] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of length `1`.<br>
1448 : !>
1449 : !> \return
1450 : !> `charIsUpper` : The output scalar or array of the same shape as the input `chr` of type `logical` of default kind \LK
1451 : !> whose value is `.true.` corresponding to each element of the input `chr` if the element is an uppercase
1452 : !> English letter, otherwise it is `.false.`.<br>
1453 : !>
1454 : !> \interface{isCharUpper}
1455 : !> \code{.F90}
1456 : !>
1457 : !> use pm_kind, only: LK
1458 : !> use pm_strASCII, only: isCharUpper
1459 : !> logical(LK) :: charIsUpper
1460 : !>
1461 : !> charIsUpper = isCharUpper(chr)
1462 : !>
1463 : !> \endcode
1464 : !>
1465 : !> \pure
1466 : !>
1467 : !> \elemental
1468 : !>
1469 : !> \see
1470 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1471 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1472 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1473 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1474 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1475 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1476 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1477 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1478 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
1479 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
1480 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1481 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1482 : !>
1483 : !> \example{isCharUpper}
1484 : !> \include{lineno} example/pm_strASCII/isCharUpper/main.F90
1485 : !> \compilef{isCharUpper}
1486 : !> \output{isCharUpper}
1487 : !> \include{lineno} example/pm_strASCII/isCharUpper/main.out.F90
1488 : !>
1489 : !> \test
1490 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1491 : !>
1492 : !> \finmain
1493 : !>
1494 : !> \author
1495 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1496 : interface isCharUpper
1497 :
1498 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1499 :
1500 : #if SK5_ENABLED
1501 : pure elemental module function isCharUpper_SK5(chr) result(charIsUpper)
1502 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1503 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharUpper_SK5
1504 : #endif
1505 : use pm_kind, only: SKC => SK5
1506 : character(1,SKC) , intent(in) :: chr
1507 : logical(LK) :: charIsUpper
1508 : end function
1509 : #endif
1510 :
1511 : #if SK4_ENABLED
1512 : pure elemental module function isCharUpper_SK4(chr) result(charIsUpper)
1513 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1514 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharUpper_SK4
1515 : #endif
1516 : use pm_kind, only: SKC => SK4
1517 : character(1,SKC) , intent(in) :: chr
1518 : logical(LK) :: charIsUpper
1519 : end function
1520 : #endif
1521 :
1522 : #if SK3_ENABLED
1523 : pure elemental module function isCharUpper_SK3(chr) result(charIsUpper)
1524 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1525 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharUpper_SK3
1526 : #endif
1527 : use pm_kind, only: SKC => SK3
1528 : character(1,SKC) , intent(in) :: chr
1529 : logical(LK) :: charIsUpper
1530 : end function
1531 : #endif
1532 :
1533 : #if SK2_ENABLED
1534 : pure elemental module function isCharUpper_SK2(chr) result(charIsUpper)
1535 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1536 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharUpper_SK2
1537 : #endif
1538 : use pm_kind, only: SKC => SK2
1539 : character(1,SKC) , intent(in) :: chr
1540 : logical(LK) :: charIsUpper
1541 : end function
1542 : #endif
1543 :
1544 : #if SK1_ENABLED
1545 : pure elemental module function isCharUpper_SK1(chr) result(charIsUpper)
1546 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1547 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharUpper_SK1
1548 : #endif
1549 : use pm_kind, only: SKC => SK1
1550 : character(1,SKC) , intent(in) :: chr
1551 : logical(LK) :: charIsUpper
1552 : end function
1553 : #endif
1554 :
1555 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1556 :
1557 : end interface
1558 :
1559 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1560 :
1561 : !> \brief
1562 : !> Generate and return `.true.` if the input single character contains an lowercase English alphabet [ALPHA_LOWER_VEC_SK](@ref ALPHA_LOWER_VEC_SK).<br>
1563 : !>
1564 : !> \param[in] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of length `1`.<br>
1565 : !>
1566 : !> \return
1567 : !> `charIsLower` : The output scalar or array of the same shape as the input `chr` of type `logical` of default kind \LK
1568 : !> whose value is `.true.` corresponding to each element of the input `chr` if the element is an lowercase
1569 : !> English letter, otherwise it is `.false.`.<br>
1570 : !>
1571 : !> \interface{isCharLower}
1572 : !> \code{.F90}
1573 : !>
1574 : !> use pm_kind, only: LK
1575 : !> use pm_strASCII, only: isCharLower
1576 : !> logical(LK) :: charIsLower
1577 : !>
1578 : !> charIsLower = isCharLower(chr)
1579 : !>
1580 : !> \endcode
1581 : !>
1582 : !> \pure
1583 : !>
1584 : !> \elemental
1585 : !>
1586 : !> \see
1587 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1588 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1589 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1590 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1591 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1592 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1593 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1594 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1595 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
1596 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
1597 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1598 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1599 : !>
1600 : !> \example{isCharLower}
1601 : !> \include{lineno} example/pm_strASCII/isCharLower/main.F90
1602 : !> \compilef{isCharLower}
1603 : !> \output{isCharLower}
1604 : !> \include{lineno} example/pm_strASCII/isCharLower/main.out.F90
1605 : !>
1606 : !> \test
1607 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1608 : !>
1609 : !> \finmain
1610 : !>
1611 : !> \author
1612 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1613 : interface isCharLower
1614 :
1615 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1616 :
1617 : #if SK5_ENABLED
1618 : pure elemental module function isCharLower_SK5(chr) result(charIsLower)
1619 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1620 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharLower_SK5
1621 : #endif
1622 : use pm_kind, only: SKC => SK5
1623 : character(1,SKC) , intent(in) :: chr
1624 : logical(LK) :: charIsLower
1625 : end function
1626 : #endif
1627 :
1628 : #if SK4_ENABLED
1629 : pure elemental module function isCharLower_SK4(chr) result(charIsLower)
1630 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1631 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharLower_SK4
1632 : #endif
1633 : use pm_kind, only: SKC => SK4
1634 : character(1,SKC) , intent(in) :: chr
1635 : logical(LK) :: charIsLower
1636 : end function
1637 : #endif
1638 :
1639 : #if SK3_ENABLED
1640 : pure elemental module function isCharLower_SK3(chr) result(charIsLower)
1641 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1642 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharLower_SK3
1643 : #endif
1644 : use pm_kind, only: SKC => SK3
1645 : character(1,SKC) , intent(in) :: chr
1646 : logical(LK) :: charIsLower
1647 : end function
1648 : #endif
1649 :
1650 : #if SK2_ENABLED
1651 : pure elemental module function isCharLower_SK2(chr) result(charIsLower)
1652 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1653 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharLower_SK2
1654 : #endif
1655 : use pm_kind, only: SKC => SK2
1656 : character(1,SKC) , intent(in) :: chr
1657 : logical(LK) :: charIsLower
1658 : end function
1659 : #endif
1660 :
1661 : #if SK1_ENABLED
1662 : pure elemental module function isCharLower_SK1(chr) result(charIsLower)
1663 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1664 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharLower_SK1
1665 : #endif
1666 : use pm_kind, only: SKC => SK1
1667 : character(1,SKC) , intent(in) :: chr
1668 : logical(LK) :: charIsLower
1669 : end function
1670 : #endif
1671 :
1672 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1673 :
1674 : end interface
1675 :
1676 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1677 :
1678 : !> \brief
1679 : !> Generate and return `.true.` if the input string contains **only** uppercase English alphabets [ALPHA_UPPER_VEC_SK](@ref ALPHA_UPPER_VEC_SK).<br>
1680 : !>
1681 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
1682 : !>
1683 : !> \return
1684 : !> `strIsUpperAll` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
1685 : !> whose value is `.true.` corresponding to each element of the input `str` if the element is an uppercase
1686 : !> English letter, otherwise it is `.false.`.<br>
1687 : !>
1688 : !> \interface{isStrUpperAll}
1689 : !> \code{.F90}
1690 : !>
1691 : !> use pm_kind, only: LK
1692 : !> use pm_strASCII, only: isStrUpperAll
1693 : !> logical(LK) :: strIsUpperAll
1694 : !>
1695 : !> strIsUpperAll = isStrUpperAll(str)
1696 : !>
1697 : !> \endcode
1698 : !>
1699 : !> \pure
1700 : !>
1701 : !> \elemental
1702 : !>
1703 : !> \note
1704 : !> The functionality of this interface can be also replicated by [isStrUpper](@ref pm_strASCII::isStrUpper),
1705 : !> \code{.F90}
1706 : !>
1707 : !> character(10) :: str
1708 : !>
1709 : !> isStrUpperAll(str) == all(isStrUpper(str))
1710 : !>
1711 : !> \endcode
1712 : !> although this generic interface is potentially faster than [isStrUpper](@ref pm_strASCII::isStrUpper).<br>
1713 : !>
1714 : !> \see
1715 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1716 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1717 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1718 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1719 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1720 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1721 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1722 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1723 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
1724 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
1725 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1726 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1727 : !>
1728 : !> \example{isStrUpperAll}
1729 : !> \include{lineno} example/pm_strASCII/isStrUpperAll/main.F90
1730 : !> \compilef{isStrUpperAll}
1731 : !> \output{isStrUpperAll}
1732 : !> \include{lineno} example/pm_strASCII/isStrUpperAll/main.out.F90
1733 : !>
1734 : !> \test
1735 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1736 : !>
1737 : !> \finmain
1738 : !>
1739 : !> \author
1740 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1741 : interface isStrUpperAll
1742 :
1743 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1744 :
1745 : #if SK5_ENABLED
1746 : pure elemental module function isStrUpperAll_SK5(str) result(strIsUpperAll)
1747 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1748 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAll_SK5
1749 : #endif
1750 : use pm_kind, only: SKC => SK5
1751 : character(*,SKC) , intent(in) :: str
1752 : logical(LK) :: strIsUpperAll
1753 : end function
1754 : #endif
1755 :
1756 : #if SK4_ENABLED
1757 : pure elemental module function isStrUpperAll_SK4(str) result(strIsUpperAll)
1758 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1759 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAll_SK4
1760 : #endif
1761 : use pm_kind, only: SKC => SK4
1762 : character(*,SKC) , intent(in) :: str
1763 : logical(LK) :: strIsUpperAll
1764 : end function
1765 : #endif
1766 :
1767 : #if SK3_ENABLED
1768 : pure elemental module function isStrUpperAll_SK3(str) result(strIsUpperAll)
1769 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1770 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAll_SK3
1771 : #endif
1772 : use pm_kind, only: SKC => SK3
1773 : character(*,SKC) , intent(in) :: str
1774 : logical(LK) :: strIsUpperAll
1775 : end function
1776 : #endif
1777 :
1778 : #if SK2_ENABLED
1779 : pure elemental module function isStrUpperAll_SK2(str) result(strIsUpperAll)
1780 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1781 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAll_SK2
1782 : #endif
1783 : use pm_kind, only: SKC => SK2
1784 : character(*,SKC) , intent(in) :: str
1785 : logical(LK) :: strIsUpperAll
1786 : end function
1787 : #endif
1788 :
1789 : #if SK1_ENABLED
1790 : pure elemental module function isStrUpperAll_SK1(str) result(strIsUpperAll)
1791 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1792 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAll_SK1
1793 : #endif
1794 : use pm_kind, only: SKC => SK1
1795 : character(*,SKC) , intent(in) :: str
1796 : logical(LK) :: strIsUpperAll
1797 : end function
1798 : #endif
1799 :
1800 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1801 :
1802 : end interface
1803 :
1804 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1805 :
1806 : !> \brief
1807 : !> Generate and return `.true.` if the input string contains **at least** one uppercase English alphabet [ALPHA_UPPER_VEC_SK](@ref ALPHA_UPPER_VEC_SK).<br>
1808 : !>
1809 : !> \param[in] str : The input scalar of type `character` of kind \SKALL.<br>
1810 : !>
1811 : !> \return
1812 : !> `strIsUpperAny` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
1813 : !> whose value is `.true.` if at least one element of the input `str` is an uppercase
1814 : !> English letter, otherwise it is `.false.`.<br>
1815 : !>
1816 : !> \interface{isStrUpperAny}
1817 : !> \code{.F90}
1818 : !>
1819 : !> use pm_kind, only: LK
1820 : !> use pm_strASCII, only: isStrUpperAny
1821 : !> logical(LK) :: strIsUpperAny
1822 : !>
1823 : !> strIsUpperAny = isStrUpperAny(str)
1824 : !>
1825 : !> \endcode
1826 : !>
1827 : !> \pure
1828 : !>
1829 : !> \elemental
1830 : !>
1831 : !> \note
1832 : !> The functionality of this interface can be also replicated by [isStrUpper](@ref pm_strASCII::isStrUpper),
1833 : !> \code{.F90}
1834 : !>
1835 : !> character(10) :: str
1836 : !>
1837 : !> isStrUpperAny(str) == any(isStrUpper(str))
1838 : !>
1839 : !> \endcode
1840 : !> although this generic interface is potentially faster than [isStrUpper](@ref pm_strASCII::isStrUpper).<br>
1841 : !>
1842 : !> \see
1843 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1844 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1845 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1846 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1847 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1848 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1849 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1850 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1851 : !> [isStrUpperAny](@ref pm_strASCII::isStrUpperAny)<br>
1852 : !> [isStrLowerAny](@ref pm_strASCII::isStrLowerAny)<br>
1853 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1854 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1855 : !>
1856 : !> \example{isStrUpperAny}
1857 : !> \include{lineno} example/pm_strASCII/isStrUpperAny/main.F90
1858 : !> \compilef{isStrUpperAny}
1859 : !> \output{isStrUpperAny}
1860 : !> \include{lineno} example/pm_strASCII/isStrUpperAny/main.out.F90
1861 : !>
1862 : !> \test
1863 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1864 : !>
1865 : !> \finmain
1866 : !>
1867 : !> \author
1868 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1869 : interface isStrUpperAny
1870 :
1871 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1872 :
1873 : #if SK5_ENABLED
1874 : pure elemental module function isStrUpperAny_SK5(str) result(strIsUpperAny)
1875 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1876 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAny_SK5
1877 : #endif
1878 : use pm_kind, only: SKC => SK5
1879 : character(*,SKC) , intent(in) :: str
1880 : logical(LK) :: strIsUpperAny
1881 : end function
1882 : #endif
1883 :
1884 : #if SK4_ENABLED
1885 : pure elemental module function isStrUpperAny_SK4(str) result(strIsUpperAny)
1886 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1887 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAny_SK4
1888 : #endif
1889 : use pm_kind, only: SKC => SK4
1890 : character(*,SKC) , intent(in) :: str
1891 : logical(LK) :: strIsUpperAny
1892 : end function
1893 : #endif
1894 :
1895 : #if SK3_ENABLED
1896 : pure elemental module function isStrUpperAny_SK3(str) result(strIsUpperAny)
1897 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1898 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAny_SK3
1899 : #endif
1900 : use pm_kind, only: SKC => SK3
1901 : character(*,SKC) , intent(in) :: str
1902 : logical(LK) :: strIsUpperAny
1903 : end function
1904 : #endif
1905 :
1906 : #if SK2_ENABLED
1907 : pure elemental module function isStrUpperAny_SK2(str) result(strIsUpperAny)
1908 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1909 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAny_SK2
1910 : #endif
1911 : use pm_kind, only: SKC => SK2
1912 : character(*,SKC) , intent(in) :: str
1913 : logical(LK) :: strIsUpperAny
1914 : end function
1915 : #endif
1916 :
1917 : #if SK1_ENABLED
1918 : pure elemental module function isStrUpperAny_SK1(str) result(strIsUpperAny)
1919 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1920 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpperAny_SK1
1921 : #endif
1922 : use pm_kind, only: SKC => SK1
1923 : character(*,SKC) , intent(in) :: str
1924 : logical(LK) :: strIsUpperAny
1925 : end function
1926 : #endif
1927 :
1928 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1929 :
1930 : end interface
1931 :
1932 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1933 :
1934 : !> \brief
1935 : !> Generate and return a `logical` vector whose elements are `.true.` <b>if and only if</b> the corresponding
1936 : !> characters in the input string belong to the uppercase English alphabet [ALPHA_UPPER_VEC_SK](@ref ALPHA_UPPER_VEC_SK).<br>
1937 : !>
1938 : !> \param[in] str : The input scalar of type `character` of kind \SKALL.<br>
1939 : !>
1940 : !> \return
1941 : !> `StrIsUpper` : The output vector of (rank `1`) of type `logical` of default kind \LK, of the same size as the length of the input `str`
1942 : !> whose elements are `.true.` <b>if and only if</b> the corresponding characters in the input string belong to the uppercase English alphabet,
1943 : !> otherwise they are `.false.`.<br>
1944 : !>
1945 : !> \interface{isStrUpper}
1946 : !> \code{.F90}
1947 : !>
1948 : !> use pm_kind, only: LK
1949 : !> use pm_strASCII, only: isStrUpper
1950 : !> logical(LK) :: StrIsUpper(len(str,IK))
1951 : !>
1952 : !> StrIsUpper = isStrUpper(str)
1953 : !>
1954 : !> \endcode
1955 : !>
1956 : !> \pure
1957 : !>
1958 : !> \see
1959 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
1960 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
1961 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
1962 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
1963 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
1964 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
1965 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
1966 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
1967 : !> [isStrUpperAny](@ref pm_strASCII::isStrUpperAny)<br>
1968 : !> [isStrLowerAny](@ref pm_strASCII::isStrLowerAny)<br>
1969 : !> [isStrUpper](@ref pm_strASCII::isStrUpper)<br>
1970 : !> [isStrLower](@ref pm_strASCII::isStrLower)<br>
1971 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
1972 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
1973 : !>
1974 : !> \example{isStrUpper}
1975 : !> \include{lineno} example/pm_strASCII/isStrUpper/main.F90
1976 : !> \compilef{isStrUpper}
1977 : !> \output{isStrUpper}
1978 : !> \include{lineno} example/pm_strASCII/isStrUpper/main.out.F90
1979 : !>
1980 : !> \test
1981 : !> [test_pm_strASCII](@ref test_pm_strASCII)
1982 : !>
1983 : !> \finmain
1984 : !>
1985 : !> \author
1986 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
1987 : interface isStrUpper
1988 :
1989 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
1990 :
1991 : #if SK5_ENABLED
1992 : pure module function isStrUpper_SK5(str) result(StrIsUpper)
1993 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
1994 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpper_SK5
1995 : #endif
1996 : use pm_kind, only: SKC => SK5
1997 : character(*,SKC) , intent(in) :: str
1998 : logical(LK) :: StrIsUpper(len(str,IK))
1999 : end function
2000 : #endif
2001 :
2002 : #if SK4_ENABLED
2003 : pure module function isStrUpper_SK4(str) result(StrIsUpper)
2004 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2005 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpper_SK4
2006 : #endif
2007 : use pm_kind, only: SKC => SK4
2008 : character(*,SKC) , intent(in) :: str
2009 : logical(LK) :: StrIsUpper(len(str,IK))
2010 : end function
2011 : #endif
2012 :
2013 : #if SK3_ENABLED
2014 : pure module function isStrUpper_SK3(str) result(StrIsUpper)
2015 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2016 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpper_SK3
2017 : #endif
2018 : use pm_kind, only: SKC => SK3
2019 : character(*,SKC) , intent(in) :: str
2020 : logical(LK) :: StrIsUpper(len(str,IK))
2021 : end function
2022 : #endif
2023 :
2024 : #if SK2_ENABLED
2025 : pure module function isStrUpper_SK2(str) result(StrIsUpper)
2026 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2027 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpper_SK2
2028 : #endif
2029 : use pm_kind, only: SKC => SK2
2030 : character(*,SKC) , intent(in) :: str
2031 : logical(LK) :: StrIsUpper(len(str,IK))
2032 : end function
2033 : #endif
2034 :
2035 : #if SK1_ENABLED
2036 : pure module function isStrUpper_SK1(str) result(StrIsUpper)
2037 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2038 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrUpper_SK1
2039 : #endif
2040 : use pm_kind, only: SKC => SK1
2041 : character(*,SKC) , intent(in) :: str
2042 : logical(LK) :: StrIsUpper(len(str,IK))
2043 : end function
2044 : #endif
2045 :
2046 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2047 :
2048 : end interface
2049 :
2050 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2051 :
2052 : !> \brief
2053 : !> Generate and return `.true.` if the input string contains **only** lowercase English alphabets [ALPHA_LOWER_VEC_SK](@ref ALPHA_LOWER_VEC_SK).<br>
2054 : !>
2055 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
2056 : !>
2057 : !> \return
2058 : !> `strIsLowerAny` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
2059 : !> whose value is `.true.` corresponding to each element of the input `str` if the element is a lowercase
2060 : !> English letter, otherwise it is `.false.`.<br>
2061 : !>
2062 : !> \interface{isStrLowerAll}
2063 : !> \code{.F90}
2064 : !>
2065 : !> use pm_kind, only: LK
2066 : !> use pm_strASCII, only: isStrLowerAll
2067 : !> logical(LK) :: strIsLowerAny
2068 : !>
2069 : !> strIsLowerAny = isStrLowerAll(str)
2070 : !>
2071 : !> \endcode
2072 : !>
2073 : !> \pure
2074 : !>
2075 : !> \elemental
2076 : !>
2077 : !> \note
2078 : !> The functionality of this interface can be also replicated by [isStrLower](@ref pm_strASCII::isStrLower),
2079 : !> \code{.F90}
2080 : !>
2081 : !> character(10) :: str
2082 : !>
2083 : !> isStrLowerAll(str) == all(isStrLower(str))
2084 : !>
2085 : !> \endcode
2086 : !> although this generic interface is potentially faster than [isStrLower](@ref pm_strASCII::isStrLower).<br>
2087 : !>
2088 : !>
2089 : !> \see
2090 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2091 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2092 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2093 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2094 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2095 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2096 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2097 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2098 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
2099 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
2100 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
2101 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2102 : !>
2103 : !> \example{isStrLowerAll}
2104 : !> \include{lineno} example/pm_strASCII/isStrLowerAll/main.F90
2105 : !> \compilef{isStrLowerAll}
2106 : !> \output{isStrLowerAll}
2107 : !> \include{lineno} example/pm_strASCII/isStrLowerAll/main.out.F90
2108 : !>
2109 : !> \test
2110 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2111 : !>
2112 : !> \finmain
2113 : !>
2114 : !> \author
2115 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2116 : interface isStrLowerAll
2117 :
2118 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2119 :
2120 : #if SK5_ENABLED
2121 : pure elemental module function isStrLowerAll_SK5(str) result(strIsLowerAll)
2122 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2123 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAll_SK5
2124 : #endif
2125 : use pm_kind, only: SKC => SK5
2126 : character(*,SKC) , intent(in) :: str
2127 : logical(LK) :: strIsLowerAll
2128 : end function
2129 : #endif
2130 :
2131 : #if SK4_ENABLED
2132 : pure elemental module function isStrLowerAll_SK4(str) result(strIsLowerAll)
2133 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2134 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAll_SK4
2135 : #endif
2136 : use pm_kind, only: SKC => SK4
2137 : character(*,SKC) , intent(in) :: str
2138 : logical(LK) :: strIsLowerAll
2139 : end function
2140 : #endif
2141 :
2142 : #if SK3_ENABLED
2143 : pure elemental module function isStrLowerAll_SK3(str) result(strIsLowerAll)
2144 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2145 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAll_SK3
2146 : #endif
2147 : use pm_kind, only: SKC => SK3
2148 : character(*,SKC) , intent(in) :: str
2149 : logical(LK) :: strIsLowerAll
2150 : end function
2151 : #endif
2152 :
2153 : #if SK2_ENABLED
2154 : pure elemental module function isStrLowerAll_SK2(str) result(strIsLowerAll)
2155 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2156 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAll_SK2
2157 : #endif
2158 : use pm_kind, only: SKC => SK2
2159 : character(*,SKC) , intent(in) :: str
2160 : logical(LK) :: strIsLowerAll
2161 : end function
2162 : #endif
2163 :
2164 : #if SK1_ENABLED
2165 : pure elemental module function isStrLowerAll_SK1(str) result(strIsLowerAll)
2166 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2167 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAll_SK1
2168 : #endif
2169 : use pm_kind, only: SKC => SK1
2170 : character(*,SKC) , intent(in) :: str
2171 : logical(LK) :: strIsLowerAll
2172 : end function
2173 : #endif
2174 :
2175 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2176 :
2177 : end interface
2178 :
2179 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2180 :
2181 : !> \brief
2182 : !> Generate and return `.true.` if the input string contains **at least** one lowercase English alphabet [ALPHA_LOWER_VEC_SK](@ref ALPHA_LOWER_VEC_SK).<br>
2183 : !>
2184 : !> \param[in] str : The input scalar of type `character` of kind \SKALL.<br>
2185 : !>
2186 : !> \return
2187 : !> `strIsLowerAny` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
2188 : !> whose value is `.true.` if at least one element of the input `str` is a lowercase
2189 : !> English letter, otherwise it is `.false.`.<br>
2190 : !>
2191 : !> \interface{isStrLowerAny}
2192 : !> \code{.F90}
2193 : !>
2194 : !> use pm_kind, only: LK
2195 : !> use pm_strASCII, only: isStrLowerAny
2196 : !> logical(LK) :: strIsLowerAny
2197 : !>
2198 : !> strIsLowerAny = isStrLowerAny(str)
2199 : !>
2200 : !> \endcode
2201 : !>
2202 : !> \pure
2203 : !>
2204 : !> \elemental
2205 : !>
2206 : !> \note
2207 : !> The functionality of this interface can be also replicated by [isStrLower](@ref pm_strASCII::isStrLower),
2208 : !> \code{.F90}
2209 : !>
2210 : !> character(10) :: str
2211 : !>
2212 : !> isStrLowerAny(str) == any(isStrLower(str))
2213 : !>
2214 : !> \endcode
2215 : !> although this generic interface is potentially faster than [isStrLower](@ref pm_strASCII::isStrLower).<br>
2216 : !>
2217 : !> \see
2218 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2219 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2220 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2221 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2222 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2223 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2224 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2225 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2226 : !> [isStrUpperAny](@ref pm_strASCII::isStrUpperAny)<br>
2227 : !> [isStrLowerAny](@ref pm_strASCII::isStrLowerAny)<br>
2228 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
2229 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2230 : !>
2231 : !> \example{isStrLowerAny}
2232 : !> \include{lineno} example/pm_strASCII/isStrLowerAny/main.F90
2233 : !> \compilef{isStrLowerAny}
2234 : !> \output{isStrLowerAny}
2235 : !> \include{lineno} example/pm_strASCII/isStrLowerAny/main.out.F90
2236 : !>
2237 : !> \test
2238 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2239 : !>
2240 : !> \finmain
2241 : !>
2242 : !> \author
2243 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2244 : interface isStrLowerAny
2245 :
2246 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2247 :
2248 : #if SK5_ENABLED
2249 : pure elemental module function isStrLowerAny_SK5(str) result(strIsLowerAny)
2250 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2251 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAny_SK5
2252 : #endif
2253 : use pm_kind, only: SKC => SK5
2254 : character(*,SKC) , intent(in) :: str
2255 : logical(LK) :: strIsLowerAny
2256 : end function
2257 : #endif
2258 :
2259 : #if SK4_ENABLED
2260 : pure elemental module function isStrLowerAny_SK4(str) result(strIsLowerAny)
2261 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2262 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAny_SK4
2263 : #endif
2264 : use pm_kind, only: SKC => SK4
2265 : character(*,SKC) , intent(in) :: str
2266 : logical(LK) :: strIsLowerAny
2267 : end function
2268 : #endif
2269 :
2270 : #if SK3_ENABLED
2271 : pure elemental module function isStrLowerAny_SK3(str) result(strIsLowerAny)
2272 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2273 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAny_SK3
2274 : #endif
2275 : use pm_kind, only: SKC => SK3
2276 : character(*,SKC) , intent(in) :: str
2277 : logical(LK) :: strIsLowerAny
2278 : end function
2279 : #endif
2280 :
2281 : #if SK2_ENABLED
2282 : pure elemental module function isStrLowerAny_SK2(str) result(strIsLowerAny)
2283 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2284 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAny_SK2
2285 : #endif
2286 : use pm_kind, only: SKC => SK2
2287 : character(*,SKC) , intent(in) :: str
2288 : logical(LK) :: strIsLowerAny
2289 : end function
2290 : #endif
2291 :
2292 : #if SK1_ENABLED
2293 : pure elemental module function isStrLowerAny_SK1(str) result(strIsLowerAny)
2294 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2295 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLowerAny_SK1
2296 : #endif
2297 : use pm_kind, only: SKC => SK1
2298 : character(*,SKC) , intent(in) :: str
2299 : logical(LK) :: strIsLowerAny
2300 : end function
2301 : #endif
2302 :
2303 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2304 :
2305 : end interface
2306 :
2307 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2308 :
2309 : !> \brief
2310 : !> Generate and return a `logical` vector whose elements are `.true.` <b>if and only if</b> the corresponding
2311 : !> characters in the input string belong to the uppercase English alphabet [ALPHA_UPPER_VEC_SK](@ref ALPHA_UPPER_VEC_SK).<br>
2312 : !>
2313 : !> \param[in] str : The input scalar of type `character` of kind \SKALL.<br>
2314 : !>
2315 : !> \return
2316 : !> `StrIsLower` : The output vector of (rank `1`) of type `logical` of default kind \LK, of the same size as the length of the input `str`
2317 : !> whose elements are `.true.` <b>if and only if</b> the corresponding characters in the input string belong to the lowercase English alphabet,
2318 : !> otherwise they are `.false.`.<br>
2319 : !>
2320 : !> \interface{isStrLower}
2321 : !> \code{.F90}
2322 : !>
2323 : !> use pm_kind, only: LK
2324 : !> use pm_strASCII, only: isStrLower
2325 : !> logical(LK) :: CaseIsLower(len(str,IK))
2326 : !>
2327 : !> StrIsLower = isStrLower(str)
2328 : !>
2329 : !> \endcode
2330 : !>
2331 : !> \pure
2332 : !>
2333 : !> \see
2334 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2335 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2336 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2337 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2338 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2339 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2340 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2341 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2342 : !> [isStrUpper](@ref pm_strASCII::isStrUpper)<br>
2343 : !> [isStrLower](@ref pm_strASCII::isStrLower)<br>
2344 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
2345 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2346 : !>
2347 : !> \example{isStrLower}
2348 : !> \include{lineno} example/pm_strASCII/isStrLower/main.F90
2349 : !> \compilef{isStrLower}
2350 : !> \output{isStrLower}
2351 : !> \include{lineno} example/pm_strASCII/isStrLower/main.out.F90
2352 : !>
2353 : !> \test
2354 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2355 : !>
2356 : !> \finmain
2357 : !>
2358 : !> \author
2359 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2360 : interface isStrLower
2361 :
2362 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2363 :
2364 : #if SK5_ENABLED
2365 : pure module function isStrLower_SK5(str) result(StrIsLower)
2366 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2367 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLower_SK5
2368 : #endif
2369 : use pm_kind, only: SKC => SK5
2370 : character(*,SKC) , intent(in) :: str
2371 : logical(LK) :: StrIsLower(len(str,IK))
2372 : end function
2373 : #endif
2374 :
2375 : #if SK4_ENABLED
2376 : pure module function isStrLower_SK4(str) result(StrIsLower)
2377 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2378 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLower_SK4
2379 : #endif
2380 : use pm_kind, only: SKC => SK4
2381 : character(*,SKC) , intent(in) :: str
2382 : logical(LK) :: StrIsLower(len(str,IK))
2383 : end function
2384 : #endif
2385 :
2386 : #if SK3_ENABLED
2387 : pure module function isStrLower_SK3(str) result(StrIsLower)
2388 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2389 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLower_SK3
2390 : #endif
2391 : use pm_kind, only: SKC => SK3
2392 : character(*,SKC) , intent(in) :: str
2393 : logical(LK) :: StrIsLower(len(str,IK))
2394 : end function
2395 : #endif
2396 :
2397 : #if SK2_ENABLED
2398 : pure module function isStrLower_SK2(str) result(StrIsLower)
2399 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2400 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLower_SK2
2401 : #endif
2402 : use pm_kind, only: SKC => SK2
2403 : character(*,SKC) , intent(in) :: str
2404 : logical(LK) :: StrIsLower(len(str,IK))
2405 : end function
2406 : #endif
2407 :
2408 : #if SK1_ENABLED
2409 : pure module function isStrLower_SK1(str) result(StrIsLower)
2410 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2411 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrLower_SK1
2412 : #endif
2413 : use pm_kind, only: SKC => SK1
2414 : character(*,SKC) , intent(in) :: str
2415 : logical(LK) :: StrIsLower(len(str,IK))
2416 : end function
2417 : #endif
2418 :
2419 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2420 :
2421 : end interface
2422 :
2423 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2424 :
2425 : !> \brief
2426 : !> Generate and return `.true.` if the input (single) character is a digit or
2427 : !> an uppercase or lowercase English alphabet [ALPHA_VEC_SK](@ref ALPHA_VEC_SK).<br>
2428 : !>
2429 : !> \param[in] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of `len = 1`.<br>
2430 : !>
2431 : !> \return
2432 : !> `charIsAlphaNum` : The output scalar or array of the same shape as the input `chr` of type `logical` of default kind \LK
2433 : !> whose value is `.true.` corresponding to each element of the input `chr` if the element belongs to
2434 : !> the set of English digits or English alphabets (lowercase or uppercase), otherwise it is `.false.`.<br>
2435 : !>
2436 : !> \interface{isCharAlphaNum}
2437 : !> \code{.F90}
2438 : !>
2439 : !> use pm_kind, only: LK
2440 : !> use pm_strASCII, only: isCharAlphaNum
2441 : !> logical(LK) :: charIsAlphaNum
2442 : !>
2443 : !> charIsAlphaNum = isCharAlphaNum(chr)
2444 : !>
2445 : !> \endcode
2446 : !>
2447 : !> \pure
2448 : !>
2449 : !> \elemental
2450 : !>
2451 : !> \see
2452 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2453 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2454 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2455 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2456 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2457 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2458 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2459 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2460 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
2461 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
2462 : !> [isCharAlphaNum](@ref pm_strASCII::isCharAlphaNum)<br>
2463 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2464 : !>
2465 : !> \example{isCharAlphaNum}
2466 : !> \include{lineno} example/pm_strASCII/isCharAlphaNum/main.F90
2467 : !> \compilef{isCharAlphaNum}
2468 : !> \output{isCharAlphaNum}
2469 : !> \include{lineno} example/pm_strASCII/isCharAlphaNum/main.out.F90
2470 : !>
2471 : !> \test
2472 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2473 : !>
2474 : !> \finmain
2475 : !>
2476 : !> \author
2477 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2478 : interface isCharAlphaNum
2479 :
2480 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2481 :
2482 : #if SK5_ENABLED
2483 : pure elemental module function isCharAlphaNum_SK5(chr) result(charIsAlphaNum)
2484 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2485 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlphaNum_SK5
2486 : #endif
2487 : use pm_kind, only: SKC => SK5
2488 : character(1,SKC) , intent(in) :: chr
2489 : logical(LK) :: charIsAlphaNum
2490 : end function
2491 : #endif
2492 :
2493 : #if SK4_ENABLED
2494 : pure elemental module function isCharAlphaNum_SK4(chr) result(charIsAlphaNum)
2495 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2496 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlphaNum_SK4
2497 : #endif
2498 : use pm_kind, only: SKC => SK4
2499 : character(1,SKC) , intent(in) :: chr
2500 : logical(LK) :: charIsAlphaNum
2501 : end function
2502 : #endif
2503 :
2504 : #if SK3_ENABLED
2505 : pure elemental module function isCharAlphaNum_SK3(chr) result(charIsAlphaNum)
2506 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2507 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlphaNum_SK3
2508 : #endif
2509 : use pm_kind, only: SKC => SK3
2510 : character(1,SKC) , intent(in) :: chr
2511 : logical(LK) :: charIsAlphaNum
2512 : end function
2513 : #endif
2514 :
2515 : #if SK2_ENABLED
2516 : pure elemental module function isCharAlphaNum_SK2(chr) result(charIsAlphaNum)
2517 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2518 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlphaNum_SK2
2519 : #endif
2520 : use pm_kind, only: SKC => SK2
2521 : character(1,SKC) , intent(in) :: chr
2522 : logical(LK) :: charIsAlphaNum
2523 : end function
2524 : #endif
2525 :
2526 : #if SK1_ENABLED
2527 : pure elemental module function isCharAlphaNum_SK1(chr) result(charIsAlphaNum)
2528 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2529 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlphaNum_SK1
2530 : #endif
2531 : use pm_kind, only: SKC => SK1
2532 : character(1,SKC) , intent(in) :: chr
2533 : logical(LK) :: charIsAlphaNum
2534 : end function
2535 : #endif
2536 :
2537 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2538 :
2539 : end interface
2540 :
2541 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2542 :
2543 : !> \brief
2544 : !> Generate and return `.true.` if the input string is **all** alphanumeric,
2545 : !> containing only digits or the English alphabet [ALPHANUM_VEC_SK](@ref ALPHANUM_VEC_SK).<br>
2546 : !>
2547 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
2548 : !>
2549 : !> \return
2550 : !> `strIsAlphaNumAll` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
2551 : !> whose value is `.true.` corresponding to each element of the input `str` if the scalar string is all digits,
2552 : !> or English alphabets, otherwise it is `.false.`.<br>
2553 : !>
2554 : !> \interface{isStrAlphaNumAll}
2555 : !> \code{.F90}
2556 : !>
2557 : !> use pm_kind, only: LK
2558 : !> use pm_strASCII, only: isStrAlphaNumAll
2559 : !> logical(LK) :: strIsAlphaNumAll
2560 : !>
2561 : !> strIsAlphaNumAll = isStrAlphaNumAll(str)
2562 : !>
2563 : !> \endcode
2564 : !>
2565 : !> \pure
2566 : !>
2567 : !> \elemental
2568 : !>
2569 : !> \note
2570 : !> The functionality of this interface can be also replicated by [isStrAlphaNum](@ref pm_strASCII::isStrAlphaNum),
2571 : !> \code{.F90}
2572 : !>
2573 : !> character(10) :: str
2574 : !>
2575 : !> isStrAlphaNumAll(str) == all(isStrAlphaNum(str))
2576 : !>
2577 : !> \endcode
2578 : !> although this generic interface is potentially faster than [isStrAlphaNum](@ref pm_strASCII::isStrAlphaNum).<br>
2579 : !>
2580 : !> \see
2581 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2582 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2583 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2584 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2585 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2586 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2587 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2588 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2589 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
2590 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
2591 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
2592 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2593 : !>
2594 : !> \example{isStrAlphaNumAll}
2595 : !> \include{lineno} example/pm_strASCII/isStrAlphaNumAll/main.F90
2596 : !> \compilef{isStrAlphaNumAll}
2597 : !> \output{isStrAlphaNumAll}
2598 : !> \include{lineno} example/pm_strASCII/isStrAlphaNumAll/main.out.F90
2599 : !>
2600 : !> \test
2601 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2602 : !>
2603 : !> \finmain
2604 : !>
2605 : !> \author
2606 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2607 : interface isStrAlphaNumAll
2608 :
2609 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2610 :
2611 : #if SK5_ENABLED
2612 : pure elemental module function isStrAlphaNumAll_SK5(str) result(strIsAlphaNumAll)
2613 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2614 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAll_SK5
2615 : #endif
2616 : use pm_kind, only: SKC => SK5
2617 : character(*,SKC) , intent(in) :: str
2618 : logical(LK) :: strIsAlphaNumAll
2619 : end function
2620 : #endif
2621 :
2622 : #if SK4_ENABLED
2623 : pure elemental module function isStrAlphaNumAll_SK4(str) result(strIsAlphaNumAll)
2624 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2625 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAll_SK4
2626 : #endif
2627 : use pm_kind, only: SKC => SK4
2628 : character(*,SKC) , intent(in) :: str
2629 : logical(LK) :: strIsAlphaNumAll
2630 : end function
2631 : #endif
2632 :
2633 : #if SK3_ENABLED
2634 : pure elemental module function isStrAlphaNumAll_SK3(str) result(strIsAlphaNumAll)
2635 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2636 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAll_SK3
2637 : #endif
2638 : use pm_kind, only: SKC => SK3
2639 : character(*,SKC) , intent(in) :: str
2640 : logical(LK) :: strIsAlphaNumAll
2641 : end function
2642 : #endif
2643 :
2644 : #if SK2_ENABLED
2645 : pure elemental module function isStrAlphaNumAll_SK2(str) result(strIsAlphaNumAll)
2646 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2647 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAll_SK2
2648 : #endif
2649 : use pm_kind, only: SKC => SK2
2650 : character(*,SKC) , intent(in) :: str
2651 : logical(LK) :: strIsAlphaNumAll
2652 : end function
2653 : #endif
2654 :
2655 : #if SK1_ENABLED
2656 : pure elemental module function isStrAlphaNumAll_SK1(str) result(strIsAlphaNumAll)
2657 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2658 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAll_SK1
2659 : #endif
2660 : use pm_kind, only: SKC => SK1
2661 : character(*,SKC) , intent(in) :: str
2662 : logical(LK) :: strIsAlphaNumAll
2663 : end function
2664 : #endif
2665 :
2666 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2667 :
2668 : end interface
2669 :
2670 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2671 :
2672 : !> \brief
2673 : !> Generate and return `.true.` if **any** characters of the input string are alphanumeric,
2674 : !> that is, only digits or the English alphabet [ALPHANUM_VEC_SK](@ref ALPHANUM_VEC_SK).<br>
2675 : !>
2676 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
2677 : !>
2678 : !> \return
2679 : !> `strIsAlphaNumAny` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK.<br>
2680 : !> If it `.true.` <b>if and only if</b> any character of the input string `str` is digits or English alphabet.<br>
2681 : !>
2682 : !> \interface{isStrAlphaNumAny}
2683 : !> \code{.F90}
2684 : !>
2685 : !> use pm_kind, only: LK
2686 : !> use pm_strASCII, only: isStrAlphaNumAny
2687 : !> logical(LK) :: strIsAlphaNumAny
2688 : !>
2689 : !> strIsAlphaNumAny = isStrAlphaNumAny(str)
2690 : !>
2691 : !> \endcode
2692 : !>
2693 : !> \pure
2694 : !>
2695 : !> \elemental
2696 : !>
2697 : !> \note
2698 : !> The functionality of this interface can be also replicated by [isStrAlphaNum](@ref pm_strASCII::isStrAlphaNum),
2699 : !> \code{.F90}
2700 : !>
2701 : !> character(10) :: str
2702 : !>
2703 : !> isStrAlphaNumAny(str) == any(isStrAlphaNum(str))
2704 : !>
2705 : !> \endcode
2706 : !> although this generic interface is potentially faster than [isStrAlphaNum](@ref pm_strASCII::isStrAlphaNum).<br>
2707 : !>
2708 : !> \see
2709 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2710 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2711 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2712 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2713 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2714 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2715 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2716 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2717 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
2718 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
2719 : !> [isStrAlphaNumAny](@ref pm_strASCII::isStrAlphaNumAny)<br>
2720 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2721 : !>
2722 : !> \example{isStrAlphaNumAny}
2723 : !> \include{lineno} example/pm_strASCII/isStrAlphaNumAny/main.F90
2724 : !> \compilef{isStrAlphaNumAny}
2725 : !> \output{isStrAlphaNumAny}
2726 : !> \include{lineno} example/pm_strASCII/isStrAlphaNumAny/main.out.F90
2727 : !>
2728 : !> \test
2729 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2730 : !>
2731 : !> \finmain
2732 : !>
2733 : !> \author
2734 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2735 : interface isStrAlphaNumAny
2736 :
2737 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2738 :
2739 : #if SK5_ENABLED
2740 : pure elemental module function isStrAlphaNumAny_SK5(str) result(strIsAlphaNumAny)
2741 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2742 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAny_SK5
2743 : #endif
2744 : use pm_kind, only: SKC => SK5
2745 : character(*,SKC) , intent(in) :: str
2746 : logical(LK) :: strIsAlphaNumAny
2747 : end function
2748 : #endif
2749 :
2750 : #if SK4_ENABLED
2751 : pure elemental module function isStrAlphaNumAny_SK4(str) result(strIsAlphaNumAny)
2752 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2753 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAny_SK4
2754 : #endif
2755 : use pm_kind, only: SKC => SK4
2756 : character(*,SKC) , intent(in) :: str
2757 : logical(LK) :: strIsAlphaNumAny
2758 : end function
2759 : #endif
2760 :
2761 : #if SK3_ENABLED
2762 : pure elemental module function isStrAlphaNumAny_SK3(str) result(strIsAlphaNumAny)
2763 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2764 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAny_SK3
2765 : #endif
2766 : use pm_kind, only: SKC => SK3
2767 : character(*,SKC) , intent(in) :: str
2768 : logical(LK) :: strIsAlphaNumAny
2769 : end function
2770 : #endif
2771 :
2772 : #if SK2_ENABLED
2773 : pure elemental module function isStrAlphaNumAny_SK2(str) result(strIsAlphaNumAny)
2774 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2775 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAny_SK2
2776 : #endif
2777 : use pm_kind, only: SKC => SK2
2778 : character(*,SKC) , intent(in) :: str
2779 : logical(LK) :: strIsAlphaNumAny
2780 : end function
2781 : #endif
2782 :
2783 : #if SK1_ENABLED
2784 : pure elemental module function isStrAlphaNumAny_SK1(str) result(strIsAlphaNumAny)
2785 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2786 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNumAny_SK1
2787 : #endif
2788 : use pm_kind, only: SKC => SK1
2789 : character(*,SKC) , intent(in) :: str
2790 : logical(LK) :: strIsAlphaNumAny
2791 : end function
2792 : #endif
2793 :
2794 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2795 :
2796 : end interface
2797 :
2798 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2799 :
2800 : !> \brief
2801 : !> Generate and return a `logical` vector whose elements are `.true.` <b>if and only if</b> the corresponding
2802 : !> characters in the input string belong to the uppercase English alphabet [ALPHA_UPPER_VEC_SK](@ref ALPHA_UPPER_VEC_SK).<br>
2803 : !>
2804 : !> \param[in] str : The input scalar of type `character` of kind \SKALL.<br>
2805 : !>
2806 : !> \return
2807 : !> `StrIsLower` : The output vector of (rank `1`) of type `logical` of default kind \LK, of the same size as the length of the input `str`
2808 : !> whose elements are `.true.` <b>if and only if</b> the corresponding characters in the input string belong to the lowercase English alphabet,
2809 : !> otherwise they are `.false.`.<br>
2810 : !>
2811 : !> \interface{isStrLower}
2812 : !> \code{.F90}
2813 : !>
2814 : !> use pm_kind, only: LK
2815 : !> use pm_strASCII, only: isStrLower
2816 : !> logical(LK) :: CaseIsLower(len(str,IK))
2817 : !>
2818 : !> StrIsLower = isStrLower(str)
2819 : !>
2820 : !> \endcode
2821 : !>
2822 : !> \pure
2823 : !>
2824 : !> \see
2825 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2826 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2827 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2828 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2829 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2830 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2831 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2832 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2833 : !> [isStrUpper](@ref pm_strASCII::isStrUpper)<br>
2834 : !> [isStrLower](@ref pm_strASCII::isStrLower)<br>
2835 : !> [isStrAlphaNumAll](@ref pm_strASCII::isStrAlphaNumAll)<br>
2836 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2837 : !>
2838 : !> \example{isStrLower}
2839 : !> \include{lineno} example/pm_strASCII/isStrLower/main.F90
2840 : !> \compilef{isStrLower}
2841 : !> \output{isStrLower}
2842 : !> \include{lineno} example/pm_strASCII/isStrLower/main.out.F90
2843 : !>
2844 : !> \test
2845 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2846 : !>
2847 : !> \finmain
2848 : !>
2849 : !> \author
2850 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2851 : interface isStrAlphaNum
2852 :
2853 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2854 :
2855 : #if SK5_ENABLED
2856 : pure module function isStrAlphaNum_SK5(str) result(StrIsAlphaNum)
2857 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2858 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNum_SK5
2859 : #endif
2860 : use pm_kind, only: SKC => SK5
2861 : character(*,SKC) , intent(in) :: str
2862 : logical(LK) :: StrIsAlphaNum(len(str,IK))
2863 : end function
2864 : #endif
2865 :
2866 : #if SK4_ENABLED
2867 : pure module function isStrAlphaNum_SK4(str) result(StrIsAlphaNum)
2868 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2869 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNum_SK4
2870 : #endif
2871 : use pm_kind, only: SKC => SK4
2872 : character(*,SKC) , intent(in) :: str
2873 : logical(LK) :: StrIsAlphaNum(len(str,IK))
2874 : end function
2875 : #endif
2876 :
2877 : #if SK3_ENABLED
2878 : pure module function isStrAlphaNum_SK3(str) result(StrIsAlphaNum)
2879 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2880 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNum_SK3
2881 : #endif
2882 : use pm_kind, only: SKC => SK3
2883 : character(*,SKC) , intent(in) :: str
2884 : logical(LK) :: StrIsAlphaNum(len(str,IK))
2885 : end function
2886 : #endif
2887 :
2888 : #if SK2_ENABLED
2889 : pure module function isStrAlphaNum_SK2(str) result(StrIsAlphaNum)
2890 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2891 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNum_SK2
2892 : #endif
2893 : use pm_kind, only: SKC => SK2
2894 : character(*,SKC) , intent(in) :: str
2895 : logical(LK) :: StrIsAlphaNum(len(str,IK))
2896 : end function
2897 : #endif
2898 :
2899 : #if SK1_ENABLED
2900 : pure module function isStrAlphaNum_SK1(str) result(StrIsAlphaNum)
2901 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2902 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaNum_SK1
2903 : #endif
2904 : use pm_kind, only: SKC => SK1
2905 : character(*,SKC) , intent(in) :: str
2906 : logical(LK) :: StrIsAlphaNum(len(str,IK))
2907 : end function
2908 : #endif
2909 :
2910 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2911 :
2912 : end interface
2913 :
2914 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2915 :
2916 : !> \brief
2917 : !> Generate and return `.true.` if the input (single) character is an
2918 : !> uppercase or lowercase English alphabet [ALPHA_VEC_SK](@ref ALPHA_VEC_SK).<br>
2919 : !>
2920 : !> \param[in] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of `len = 1`.<br>
2921 : !>
2922 : !> \return
2923 : !> `charIsAlpha` : The output scalar or array of the same shape as the input `chr` of type `logical` of default kind \LK
2924 : !> whose value is `.true.` corresponding to each element of the input `chr` if the element belongs to
2925 : !> the English alphabets (lowercase or uppercase), otherwise it is `.false.`.<br>
2926 : !>
2927 : !> \interface{isCharAlpha}
2928 : !> \code{.F90}
2929 : !>
2930 : !> use pm_kind, only: LK
2931 : !> use pm_strASCII, only: isCharAlpha
2932 : !> logical(LK) :: charIsAlpha
2933 : !>
2934 : !> charIsAlpha = isCharAlpha(chr)
2935 : !>
2936 : !> \endcode
2937 : !>
2938 : !> \pure
2939 : !>
2940 : !> \elemental
2941 : !>
2942 : !> \see
2943 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
2944 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
2945 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
2946 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
2947 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
2948 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
2949 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
2950 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
2951 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
2952 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
2953 : !> [isCharAlpha](@ref pm_strASCII::isCharAlpha)<br>
2954 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
2955 : !>
2956 : !> \example{isCharAlpha}
2957 : !> \include{lineno} example/pm_strASCII/isCharAlpha/main.F90
2958 : !> \compilef{isCharAlpha}
2959 : !> \output{isCharAlpha}
2960 : !> \include{lineno} example/pm_strASCII/isCharAlpha/main.out.F90
2961 : !>
2962 : !> \test
2963 : !> [test_pm_strASCII](@ref test_pm_strASCII)
2964 : !>
2965 : !> \finmain
2966 : !>
2967 : !> \author
2968 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
2969 : interface isCharAlpha
2970 :
2971 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
2972 :
2973 : #if SK5_ENABLED
2974 : pure elemental module function isCharAlpha_SK5(chr) result(charIsAlpha)
2975 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2976 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlpha_SK5
2977 : #endif
2978 : use pm_kind, only: SKC => SK5
2979 : character(1,SKC) , intent(in) :: chr
2980 : logical(LK) :: charIsAlpha
2981 : end function
2982 : #endif
2983 :
2984 : #if SK4_ENABLED
2985 : pure elemental module function isCharAlpha_SK4(chr) result(charIsAlpha)
2986 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2987 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlpha_SK4
2988 : #endif
2989 : use pm_kind, only: SKC => SK4
2990 : character(1,SKC) , intent(in) :: chr
2991 : logical(LK) :: charIsAlpha
2992 : end function
2993 : #endif
2994 :
2995 : #if SK3_ENABLED
2996 : pure elemental module function isCharAlpha_SK3(chr) result(charIsAlpha)
2997 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
2998 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlpha_SK3
2999 : #endif
3000 : use pm_kind, only: SKC => SK3
3001 : character(1,SKC) , intent(in) :: chr
3002 : logical(LK) :: charIsAlpha
3003 : end function
3004 : #endif
3005 :
3006 : #if SK2_ENABLED
3007 : pure elemental module function isCharAlpha_SK2(chr) result(charIsAlpha)
3008 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3009 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlpha_SK2
3010 : #endif
3011 : use pm_kind, only: SKC => SK2
3012 : character(1,SKC) , intent(in) :: chr
3013 : logical(LK) :: charIsAlpha
3014 : end function
3015 : #endif
3016 :
3017 : #if SK1_ENABLED
3018 : pure elemental module function isCharAlpha_SK1(chr) result(charIsAlpha)
3019 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3020 : !DEC$ ATTRIBUTES DLLEXPORT :: isCharAlpha_SK1
3021 : #endif
3022 : use pm_kind, only: SKC => SK1
3023 : character(1,SKC) , intent(in) :: chr
3024 : logical(LK) :: charIsAlpha
3025 : end function
3026 : #endif
3027 :
3028 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3029 :
3030 : end interface
3031 :
3032 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3033 :
3034 : !> \brief
3035 : !> Generate and return `.true.` if the input string is **all** alphabetic,
3036 : !> containing only the English alphabet [ALPHA_VEC_SK](@ref ALPHA_VEC_SK).<br>
3037 : !>
3038 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
3039 : !>
3040 : !> \return
3041 : !> `strIsAlphaAll` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK
3042 : !> whose value is `.true.` corresponding to each element of the input `str` if the scalar string is all
3043 : !> English alphabets, otherwise it is `.false.`.<br>
3044 : !>
3045 : !> \interface{isStrAlphaAll}
3046 : !> \code{.F90}
3047 : !>
3048 : !> use pm_kind, only: LK
3049 : !> use pm_strASCII, only: isStrAlphaAll
3050 : !> logical(LK) :: strIsAlphaAll
3051 : !>
3052 : !> strIsAlphaAll = isStrAlphaAll(str)
3053 : !>
3054 : !> \endcode
3055 : !>
3056 : !> \pure
3057 : !>
3058 : !> \elemental
3059 : !>
3060 : !> \note
3061 : !> The functionality of this interface can be also replicated by [isStrAlpha](@ref pm_strASCII::isStrAlpha),
3062 : !> \code{.F90}
3063 : !>
3064 : !> character(10) :: str
3065 : !>
3066 : !> isStrAlphaAll(str) == all(isStrAlpha(str))
3067 : !>
3068 : !> \endcode
3069 : !> although this generic interface is potentially faster than [isStrAlpha](@ref pm_strASCII::isStrAlpha).<br>
3070 : !>
3071 : !> \see
3072 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
3073 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
3074 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
3075 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
3076 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
3077 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
3078 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3079 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3080 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3081 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3082 : !> [isStrAlphaAll](@ref pm_strASCII::isStrAlphaAll)<br>
3083 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
3084 : !>
3085 : !> \example{isStrAlphaAll}
3086 : !> \include{lineno} example/pm_strASCII/isStrAlphaAll/main.F90
3087 : !> \compilef{isStrAlphaAll}
3088 : !> \output{isStrAlphaAll}
3089 : !> \include{lineno} example/pm_strASCII/isStrAlphaAll/main.out.F90
3090 : !>
3091 : !> \test
3092 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3093 : !>
3094 : !> \finmain
3095 : !>
3096 : !> \author
3097 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3098 : interface isStrAlphaAll
3099 :
3100 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3101 :
3102 : #if SK5_ENABLED
3103 : pure elemental module function isStrAlphaAll_SK5(str) result(strIsAlphaAll)
3104 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3105 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAll_SK5
3106 : #endif
3107 : use pm_kind, only: SKC => SK5
3108 : character(*,SKC) , intent(in) :: str
3109 : logical(LK) :: strIsAlphaAll
3110 : end function
3111 : #endif
3112 :
3113 : #if SK4_ENABLED
3114 : pure elemental module function isStrAlphaAll_SK4(str) result(strIsAlphaAll)
3115 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3116 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAll_SK4
3117 : #endif
3118 : use pm_kind, only: SKC => SK4
3119 : character(*,SKC) , intent(in) :: str
3120 : logical(LK) :: strIsAlphaAll
3121 : end function
3122 : #endif
3123 :
3124 : #if SK3_ENABLED
3125 : pure elemental module function isStrAlphaAll_SK3(str) result(strIsAlphaAll)
3126 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3127 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAll_SK3
3128 : #endif
3129 : use pm_kind, only: SKC => SK3
3130 : character(*,SKC) , intent(in) :: str
3131 : logical(LK) :: strIsAlphaAll
3132 : end function
3133 : #endif
3134 :
3135 : #if SK2_ENABLED
3136 : pure elemental module function isStrAlphaAll_SK2(str) result(strIsAlphaAll)
3137 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3138 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAll_SK2
3139 : #endif
3140 : use pm_kind, only: SKC => SK2
3141 : character(*,SKC) , intent(in) :: str
3142 : logical(LK) :: strIsAlphaAll
3143 : end function
3144 : #endif
3145 :
3146 : #if SK1_ENABLED
3147 : pure elemental module function isStrAlphaAll_SK1(str) result(strIsAlphaAll)
3148 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3149 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAll_SK1
3150 : #endif
3151 : use pm_kind, only: SKC => SK1
3152 : character(*,SKC) , intent(in) :: str
3153 : logical(LK) :: strIsAlphaAll
3154 : end function
3155 : #endif
3156 :
3157 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3158 :
3159 : end interface
3160 :
3161 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3162 :
3163 : !> \brief
3164 : !> Generate and return `.true.` if **any** characters of the input string are alphabetic,
3165 : !> that is, only the English alphabet [ALPHA_VEC_SK](@ref ALPHA_VEC_SK).<br>
3166 : !>
3167 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
3168 : !>
3169 : !> \return
3170 : !> `strIsAlphaAny` : The output scalar or array of the same shape as the input `str` of type `logical` of default kind \LK.<br>
3171 : !> If it `.true.` <b>if and only if</b> any character of the input string `str` is English alphabet.<br>
3172 : !>
3173 : !> \interface{isStrAlphaAny}
3174 : !> \code{.F90}
3175 : !>
3176 : !> use pm_kind, only: LK
3177 : !> use pm_strASCII, only: isStrAlphaAny
3178 : !> logical(LK) :: strIsAlphaAny
3179 : !>
3180 : !> strIsAlphaAny = isStrAlphaAny(str)
3181 : !>
3182 : !> \endcode
3183 : !>
3184 : !> \pure
3185 : !>
3186 : !> \elemental
3187 : !>
3188 : !> \note
3189 : !> The functionality of this interface can be also replicated by [isStrAlpha](@ref pm_strASCII::isStrAlpha),
3190 : !> \code{.F90}
3191 : !>
3192 : !> character(10) :: str
3193 : !>
3194 : !> isStrAlphaAny(str) == any(isStrAlpha(str))
3195 : !>
3196 : !> \endcode
3197 : !> although this generic interface is potentially faster than [isStrAlpha](@ref pm_strASCII::isStrAlpha).<br>
3198 : !>
3199 : !> \see
3200 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
3201 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
3202 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
3203 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
3204 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
3205 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
3206 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3207 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3208 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3209 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3210 : !> [isStrAlphaAny](@ref pm_strASCII::isStrAlphaAny)<br>
3211 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
3212 : !>
3213 : !> \example{isStrAlphaAny}
3214 : !> \include{lineno} example/pm_strASCII/isStrAlphaAny/main.F90
3215 : !> \compilef{isStrAlphaAny}
3216 : !> \output{isStrAlphaAny}
3217 : !> \include{lineno} example/pm_strASCII/isStrAlphaAny/main.out.F90
3218 : !>
3219 : !> \test
3220 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3221 : !>
3222 : !> \finmain
3223 : !>
3224 : !> \author
3225 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3226 : interface isStrAlphaAny
3227 :
3228 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3229 :
3230 : #if SK5_ENABLED
3231 : pure elemental module function isStrAlphaAny_SK5(str) result(strIsAlphaAny)
3232 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3233 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAny_SK5
3234 : #endif
3235 : use pm_kind, only: SKC => SK5
3236 : character(*,SKC) , intent(in) :: str
3237 : logical(LK) :: strIsAlphaAny
3238 : end function
3239 : #endif
3240 :
3241 : #if SK4_ENABLED
3242 : pure elemental module function isStrAlphaAny_SK4(str) result(strIsAlphaAny)
3243 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3244 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAny_SK4
3245 : #endif
3246 : use pm_kind, only: SKC => SK4
3247 : character(*,SKC) , intent(in) :: str
3248 : logical(LK) :: strIsAlphaAny
3249 : end function
3250 : #endif
3251 :
3252 : #if SK3_ENABLED
3253 : pure elemental module function isStrAlphaAny_SK3(str) result(strIsAlphaAny)
3254 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3255 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAny_SK3
3256 : #endif
3257 : use pm_kind, only: SKC => SK3
3258 : character(*,SKC) , intent(in) :: str
3259 : logical(LK) :: strIsAlphaAny
3260 : end function
3261 : #endif
3262 :
3263 : #if SK2_ENABLED
3264 : pure elemental module function isStrAlphaAny_SK2(str) result(strIsAlphaAny)
3265 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3266 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAny_SK2
3267 : #endif
3268 : use pm_kind, only: SKC => SK2
3269 : character(*,SKC) , intent(in) :: str
3270 : logical(LK) :: strIsAlphaAny
3271 : end function
3272 : #endif
3273 :
3274 : #if SK1_ENABLED
3275 : pure elemental module function isStrAlphaAny_SK1(str) result(strIsAlphaAny)
3276 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3277 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlphaAny_SK1
3278 : #endif
3279 : use pm_kind, only: SKC => SK1
3280 : character(*,SKC) , intent(in) :: str
3281 : logical(LK) :: strIsAlphaAny
3282 : end function
3283 : #endif
3284 :
3285 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3286 :
3287 : end interface
3288 :
3289 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3290 :
3291 : !> \brief
3292 : !> Generate and return a `logical` vector whose elements are `.true.` <b>if and only if</b> the corresponding
3293 : !> characters in the input string belong to the uppercase English alphabet [ALPHA_UPPER_VEC_SK](@ref ALPHA_UPPER_VEC_SK).<br>
3294 : !>
3295 : !> \param[in] str : The input scalar of type `character` of kind \SKALL.<br>
3296 : !>
3297 : !> \return
3298 : !> `StrIsLower` : The output vector of (rank `1`) of type `logical` of default kind \LK, of the same size as the length of the input `str`
3299 : !> whose elements are `.true.` <b>if and only if</b> the corresponding characters in the input string belong to the lowercase English alphabet,
3300 : !> otherwise they are `.false.`.<br>
3301 : !>
3302 : !> \interface{isStrLower}
3303 : !> \code{.F90}
3304 : !>
3305 : !> use pm_kind, only: LK
3306 : !> use pm_strASCII, only: isStrLower
3307 : !> logical(LK) :: CaseIsLower(len(str,IK))
3308 : !>
3309 : !> StrIsLower = isStrLower(str)
3310 : !>
3311 : !> \endcode
3312 : !>
3313 : !> \pure
3314 : !>
3315 : !> \see
3316 : !> [isStrReal](@ref pm_strASCII::isStrReal)<br>
3317 : !> [isCharDigit](@ref pm_strASCII::isCharDigit)<br>
3318 : !> [isStrNumber](@ref pm_strASCII::isStrNumber)<br>
3319 : !> [isStrDigitAll](@ref pm_strASCII::isStrDigitAll)<br>
3320 : !> [isStrInteger](@ref pm_strASCII::isStrInteger)<br>
3321 : !> [isStrComplex](@ref pm_strASCII::isStrComplex)<br>
3322 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3323 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3324 : !> [isStrUpper](@ref pm_strASCII::isStrUpper)<br>
3325 : !> [isStrLower](@ref pm_strASCII::isStrLower)<br>
3326 : !> [isStrAlphaAll](@ref pm_strASCII::isStrAlphaAll)<br>
3327 : !> [isStrAlpha](@ref pm_strASCII::isStrAlpha)<br>
3328 : !>
3329 : !> \example{isStrLower}
3330 : !> \include{lineno} example/pm_strASCII/isStrLower/main.F90
3331 : !> \compilef{isStrLower}
3332 : !> \output{isStrLower}
3333 : !> \include{lineno} example/pm_strASCII/isStrLower/main.out.F90
3334 : !>
3335 : !> \test
3336 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3337 : !>
3338 : !> \finmain
3339 : !>
3340 : !> \author
3341 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3342 : interface isStrAlpha
3343 :
3344 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3345 :
3346 : #if SK5_ENABLED
3347 : pure module function isStrAlpha_SK5(str) result(StrIsAlpha)
3348 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3349 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlpha_SK5
3350 : #endif
3351 : use pm_kind, only: SKC => SK5
3352 : character(*,SKC) , intent(in) :: str
3353 : logical(LK) :: StrIsAlpha(len(str,IK))
3354 : end function
3355 : #endif
3356 :
3357 : #if SK4_ENABLED
3358 : pure module function isStrAlpha_SK4(str) result(StrIsAlpha)
3359 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3360 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlpha_SK4
3361 : #endif
3362 : use pm_kind, only: SKC => SK4
3363 : character(*,SKC) , intent(in) :: str
3364 : logical(LK) :: StrIsAlpha(len(str,IK))
3365 : end function
3366 : #endif
3367 :
3368 : #if SK3_ENABLED
3369 : pure module function isStrAlpha_SK3(str) result(StrIsAlpha)
3370 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3371 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlpha_SK3
3372 : #endif
3373 : use pm_kind, only: SKC => SK3
3374 : character(*,SKC) , intent(in) :: str
3375 : logical(LK) :: StrIsAlpha(len(str,IK))
3376 : end function
3377 : #endif
3378 :
3379 : #if SK2_ENABLED
3380 : pure module function isStrAlpha_SK2(str) result(StrIsAlpha)
3381 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3382 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlpha_SK2
3383 : #endif
3384 : use pm_kind, only: SKC => SK2
3385 : character(*,SKC) , intent(in) :: str
3386 : logical(LK) :: StrIsAlpha(len(str,IK))
3387 : end function
3388 : #endif
3389 :
3390 : #if SK1_ENABLED
3391 : pure module function isStrAlpha_SK1(str) result(StrIsAlpha)
3392 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3393 : !DEC$ ATTRIBUTES DLLEXPORT :: isStrAlpha_SK1
3394 : #endif
3395 : use pm_kind, only: SKC => SK1
3396 : character(*,SKC) , intent(in) :: str
3397 : logical(LK) :: StrIsAlpha(len(str,IK))
3398 : end function
3399 : #endif
3400 :
3401 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3402 :
3403 : end interface
3404 :
3405 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3406 :
3407 : !> \brief
3408 : !> Generate and return the input character where the lowercase English alphabet is converted to uppercase letter.<br>
3409 : !>
3410 : !> \param[in] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of length `1`.<br>
3411 : !>
3412 : !> \return
3413 : !> `chrUpper` : The output scalar or array of the same type, kind, rank, and `len` type parameter as the input `chr`
3414 : !> containing the input character where the lowercase English alphabet is converted to uppercase letter.<br>
3415 : !>
3416 : !> \interface{getCharUpper}
3417 : !> \code{.F90}
3418 : !>
3419 : !> use pm_strASCII, only: getCharUpper
3420 : !> character(len(chr),kind(chr)):: chrUpper(size(chr))
3421 : !>
3422 : !> chrUpper = getCharUpper(chr)
3423 : !>
3424 : !> \endcode
3425 : !>
3426 : !> \pure
3427 : !>
3428 : !> \elemental
3429 : !>
3430 : !> \see
3431 : !> [getCharUpper](@ref pm_strASCII::getCharUpper)<br>
3432 : !> [setCharUpper](@ref pm_strASCII::setCharUpper)<br>
3433 : !> [getCharLower](@ref pm_strASCII::getCharLower)<br>
3434 : !> [setCharLower](@ref pm_strASCII::setCharLower)<br>
3435 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3436 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3437 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3438 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3439 : !>
3440 : !> \example{getCharUpper}
3441 : !> \include{lineno} example/pm_strASCII/getCharUpper/main.F90
3442 : !> \compilef{getCharUpper}
3443 : !> \output{getCharUpper}
3444 : !> \include{lineno} example/pm_strASCII/getCharUpper/main.out.F90
3445 : !>
3446 : !> \test
3447 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3448 : !>
3449 : !> \finmain
3450 : !>
3451 : !> \author
3452 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3453 : interface getCharUpper
3454 :
3455 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3456 :
3457 : #if SK5_ENABLED
3458 : pure elemental module function getCharUpper_SK5(chr) result(chrUpper)
3459 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3460 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharUpper_SK5
3461 : #endif
3462 : use pm_kind, only: SKC => SK5
3463 : character(1,SKC) , intent(in) :: chr
3464 : character(1,SKC) :: chrUpper
3465 : end function
3466 : #endif
3467 :
3468 : #if SK4_ENABLED
3469 : pure elemental module function getCharUpper_SK4(chr) result(chrUpper)
3470 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3471 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharUpper_SK4
3472 : #endif
3473 : use pm_kind, only: SKC => SK4
3474 : character(1,SKC) , intent(in) :: chr
3475 : character(1,SKC) :: chrUpper
3476 : end function
3477 : #endif
3478 :
3479 : #if SK3_ENABLED
3480 : pure elemental module function getCharUpper_SK3(chr) result(chrUpper)
3481 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3482 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharUpper_SK3
3483 : #endif
3484 : use pm_kind, only: SKC => SK3
3485 : character(1,SKC) , intent(in) :: chr
3486 : character(1,SKC) :: chrUpper
3487 : end function
3488 : #endif
3489 :
3490 : #if SK2_ENABLED
3491 : pure elemental module function getCharUpper_SK2(chr) result(chrUpper)
3492 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3493 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharUpper_SK2
3494 : #endif
3495 : use pm_kind, only: SKC => SK2
3496 : character(1,SKC) , intent(in) :: chr
3497 : character(1,SKC) :: chrUpper
3498 : end function
3499 : #endif
3500 :
3501 : #if SK1_ENABLED
3502 : pure elemental module function getCharUpper_SK1(chr) result(chrUpper)
3503 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3504 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharUpper_SK1
3505 : #endif
3506 : use pm_kind, only: SKC => SK1
3507 : character(1,SKC) , intent(in) :: chr
3508 : character(1,SKC) :: chrUpper
3509 : end function
3510 : #endif
3511 :
3512 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3513 :
3514 : end interface
3515 :
3516 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3517 :
3518 : !> \brief
3519 : !> Replace any lowercase English alphabet in the input character with the corresponding uppercase English letter.<br>
3520 : !>
3521 : !> \param[inout] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of length `1`.<br>
3522 : !> On output, any lowercase English letter will be replaced with the corresponding uppercase letter.<br>
3523 : !>
3524 : !> \interface{setCharUpper}
3525 : !> \code{.F90}
3526 : !>
3527 : !> use pm_strASCII, only: setCharUpper
3528 : !>
3529 : !> call setCharUpper(chr)
3530 : !>
3531 : !> \endcode
3532 : !>
3533 : !> \pure
3534 : !>
3535 : !> \elemental
3536 : !>
3537 : !> \see
3538 : !> [setCharUpper](@ref pm_strASCII::setCharUpper)<br>
3539 : !> [setCharUpper](@ref pm_strASCII::setCharUpper)<br>
3540 : !> [getCharLower](@ref pm_strASCII::getCharLower)<br>
3541 : !> [setCharLower](@ref pm_strASCII::setCharLower)<br>
3542 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3543 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3544 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3545 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3546 : !>
3547 : !> \example{setCharUpper}
3548 : !> \include{lineno} example/pm_strASCII/setCharUpper/main.F90
3549 : !> \compilef{setCharUpper}
3550 : !> \output{setCharUpper}
3551 : !> \include{lineno} example/pm_strASCII/setCharUpper/main.out.F90
3552 : !>
3553 : !> \test
3554 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3555 : !>
3556 : !> \finmain
3557 : !>
3558 : !> \author
3559 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3560 : interface setCharUpper
3561 :
3562 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3563 :
3564 : #if SK5_ENABLED
3565 : pure elemental module subroutine setCharUpper_SK5(chr)
3566 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3567 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharUpper_SK5
3568 : #endif
3569 : use pm_kind, only: SKC => SK5
3570 : character(1,SKC) , intent(inout) :: chr
3571 : end subroutine
3572 : #endif
3573 :
3574 : #if SK4_ENABLED
3575 : pure elemental module subroutine setCharUpper_SK4(chr)
3576 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3577 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharUpper_SK4
3578 : #endif
3579 : use pm_kind, only: SKC => SK4
3580 : character(1,SKC) , intent(inout) :: chr
3581 : end subroutine
3582 : #endif
3583 :
3584 : #if SK3_ENABLED
3585 : pure elemental module subroutine setCharUpper_SK3(chr)
3586 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3587 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharUpper_SK3
3588 : #endif
3589 : use pm_kind, only: SKC => SK3
3590 : character(1,SKC) , intent(inout) :: chr
3591 : end subroutine
3592 : #endif
3593 :
3594 : #if SK2_ENABLED
3595 : pure elemental module subroutine setCharUpper_SK2(chr)
3596 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3597 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharUpper_SK2
3598 : #endif
3599 : use pm_kind, only: SKC => SK2
3600 : character(1,SKC) , intent(inout) :: chr
3601 : end subroutine
3602 : #endif
3603 :
3604 : #if SK1_ENABLED
3605 : pure elemental module subroutine setCharUpper_SK1(chr)
3606 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3607 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharUpper_SK1
3608 : #endif
3609 : use pm_kind, only: SKC => SK1
3610 : character(1,SKC) , intent(inout) :: chr
3611 : end subroutine
3612 : #endif
3613 :
3614 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3615 :
3616 : end interface
3617 :
3618 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3619 :
3620 : !> \brief
3621 : !> Generate and return the input character where the uppercase English alphabet is converted to lowercase letter.<br>
3622 : !>
3623 : !> \param[in] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of length `1`.<br>
3624 : !>
3625 : !> \return
3626 : !> `chrUpper` : The output scalar or array of the same type, kind, rank, and `len` type parameter as the input `chr`
3627 : !> containing the input character where the uppercase English alphabet is converted to uppercase letter.<br>
3628 : !>
3629 : !> \interface{getCharLower}
3630 : !> \code{.F90}
3631 : !>
3632 : !> use pm_strASCII, only: getCharLower
3633 : !> character(len(chr),kind(chr)):: chrLower(size(chr))
3634 : !>
3635 : !> chrLower = getCharLower(chr)
3636 : !>
3637 : !> \endcode
3638 : !>
3639 : !> \pure
3640 : !>
3641 : !> \elemental
3642 : !>
3643 : !> \see
3644 : !> [getCharLower](@ref pm_strASCII::getCharLower)<br>
3645 : !> [setCharLower](@ref pm_strASCII::setCharLower)<br>
3646 : !> [getCharLower](@ref pm_strASCII::getCharLower)<br>
3647 : !> [setCharLower](@ref pm_strASCII::setCharLower)<br>
3648 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3649 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3650 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3651 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3652 : !>
3653 : !> \example{getCharLower}
3654 : !> \include{lineno} example/pm_strASCII/getCharLower/main.F90
3655 : !> \compilef{getCharLower}
3656 : !> \output{getCharLower}
3657 : !> \include{lineno} example/pm_strASCII/getCharLower/main.out.F90
3658 : !>
3659 : !> \test
3660 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3661 : !>
3662 : !> \finmain
3663 : !>
3664 : !> \author
3665 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3666 : interface getCharLower
3667 :
3668 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3669 :
3670 : #if SK5_ENABLED
3671 : pure elemental module function getCharLower_SK5(chr) result(chrLower)
3672 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3673 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharLower_SK5
3674 : #endif
3675 : use pm_kind, only: SKC => SK5
3676 : character(1,SKC) , intent(in) :: chr
3677 : character(1,SKC) :: chrLower
3678 : end function
3679 : #endif
3680 :
3681 : #if SK4_ENABLED
3682 : pure elemental module function getCharLower_SK4(chr) result(chrLower)
3683 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3684 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharLower_SK4
3685 : #endif
3686 : use pm_kind, only: SKC => SK4
3687 : character(1,SKC) , intent(in) :: chr
3688 : character(1,SKC) :: chrLower
3689 : end function
3690 : #endif
3691 :
3692 : #if SK3_ENABLED
3693 : pure elemental module function getCharLower_SK3(chr) result(chrLower)
3694 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3695 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharLower_SK3
3696 : #endif
3697 : use pm_kind, only: SKC => SK3
3698 : character(1,SKC) , intent(in) :: chr
3699 : character(1,SKC) :: chrLower
3700 : end function
3701 : #endif
3702 :
3703 : #if SK2_ENABLED
3704 : pure elemental module function getCharLower_SK2(chr) result(chrLower)
3705 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3706 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharLower_SK2
3707 : #endif
3708 : use pm_kind, only: SKC => SK2
3709 : character(1,SKC) , intent(in) :: chr
3710 : character(1,SKC) :: chrLower
3711 : end function
3712 : #endif
3713 :
3714 : #if SK1_ENABLED
3715 : pure elemental module function getCharLower_SK1(chr) result(chrLower)
3716 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3717 : !DEC$ ATTRIBUTES DLLEXPORT :: getCharLower_SK1
3718 : #endif
3719 : use pm_kind, only: SKC => SK1
3720 : character(1,SKC) , intent(in) :: chr
3721 : character(1,SKC) :: chrLower
3722 : end function
3723 : #endif
3724 :
3725 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3726 :
3727 : end interface
3728 :
3729 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3730 :
3731 : !> \brief
3732 : !> Replace any uppercase English alphabet in the input character with the corresponding lowercase English letter.<br>
3733 : !>
3734 : !> \param[inout] chr : The input scalar or array of arbitrary rank of type `character` of kind \SKALL of length `1`.<br>
3735 : !> On output, any uppercase English letter will be replaced with the corresponding lowercase letter.<br>
3736 : !>
3737 : !> \interface{setCharLower}
3738 : !> \code{.F90}
3739 : !>
3740 : !> use pm_strASCII, only: setCharLower
3741 : !>
3742 : !> call setCharLower(chr)
3743 : !>
3744 : !> \endcode
3745 : !>
3746 : !> \pure
3747 : !>
3748 : !> \elemental
3749 : !>
3750 : !> \see
3751 : !> [setCharLower](@ref pm_strASCII::setCharLower)<br>
3752 : !> [setCharLower](@ref pm_strASCII::setCharLower)<br>
3753 : !> [getCharLower](@ref pm_strASCII::getCharLower)<br>
3754 : !> [setCharLower](@ref pm_strASCII::setCharLower)<br>
3755 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3756 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3757 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3758 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3759 : !>
3760 : !> \example{setCharLower}
3761 : !> \include{lineno} example/pm_strASCII/setCharLower/main.F90
3762 : !> \compilef{setCharLower}
3763 : !> \output{setCharLower}
3764 : !> \include{lineno} example/pm_strASCII/setCharLower/main.out.F90
3765 : !>
3766 : !> \test
3767 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3768 : !>
3769 : !> \finmain
3770 : !>
3771 : !> \author
3772 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3773 : interface setCharLower
3774 :
3775 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3776 :
3777 : #if SK5_ENABLED
3778 : pure elemental module subroutine setCharLower_SK5(chr)
3779 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3780 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharLower_SK5
3781 : #endif
3782 : use pm_kind, only: SKC => SK5
3783 : character(1,SKC) , intent(inout) :: chr
3784 : end subroutine
3785 : #endif
3786 :
3787 : #if SK4_ENABLED
3788 : pure elemental module subroutine setCharLower_SK4(chr)
3789 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3790 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharLower_SK4
3791 : #endif
3792 : use pm_kind, only: SKC => SK4
3793 : character(1,SKC) , intent(inout) :: chr
3794 : end subroutine
3795 : #endif
3796 :
3797 : #if SK3_ENABLED
3798 : pure elemental module subroutine setCharLower_SK3(chr)
3799 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3800 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharLower_SK3
3801 : #endif
3802 : use pm_kind, only: SKC => SK3
3803 : character(1,SKC) , intent(inout) :: chr
3804 : end subroutine
3805 : #endif
3806 :
3807 : #if SK2_ENABLED
3808 : pure elemental module subroutine setCharLower_SK2(chr)
3809 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3810 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharLower_SK2
3811 : #endif
3812 : use pm_kind, only: SKC => SK2
3813 : character(1,SKC) , intent(inout) :: chr
3814 : end subroutine
3815 : #endif
3816 :
3817 : #if SK1_ENABLED
3818 : pure elemental module subroutine setCharLower_SK1(chr)
3819 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3820 : !DEC$ ATTRIBUTES DLLEXPORT :: setCharLower_SK1
3821 : #endif
3822 : use pm_kind, only: SKC => SK1
3823 : character(1,SKC) , intent(inout) :: chr
3824 : end subroutine
3825 : #endif
3826 :
3827 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3828 :
3829 : end interface
3830 :
3831 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3832 :
3833 : !> \brief
3834 : !> Generate and return the input string where the lowercase English alphabets are all converted to uppercase letters.<br>
3835 : !>
3836 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
3837 : !>
3838 : !> \return
3839 : !> `strUpper` : The output scalar or array of the same type, kind, and rank as the input `str` containing
3840 : !> the input string where the lowercase English alphabets are all converted to uppercase letters.<br>
3841 : !>
3842 : !> \interface{getStrUpper}
3843 : !> \code{.F90}
3844 : !>
3845 : !> use pm_strASCII, only: getStrUpper
3846 : !> character(len(str,IK),kind(str)) :: strUpper(size(str))
3847 : !>
3848 : !> strUpper = getStrUpper(str)
3849 : !>
3850 : !> \endcode
3851 : !>
3852 : !> \pure
3853 : !>
3854 : !> \elemental
3855 : !>
3856 : !> \see
3857 : !> [getStrUpper](@ref pm_strASCII::getStrUpper)<br>
3858 : !> [setStrUpper](@ref pm_strASCII::setStrUpper)<br>
3859 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
3860 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
3861 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3862 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3863 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3864 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3865 : !>
3866 : !> \example{getStrUpper}
3867 : !> \include{lineno} example/pm_strASCII/getStrUpper/main.F90
3868 : !> \compilef{getStrUpper}
3869 : !> \output{getStrUpper}
3870 : !> \include{lineno} example/pm_strASCII/getStrUpper/main.out.F90
3871 : !>
3872 : !> \test
3873 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3874 : !>
3875 : !> \finmain
3876 : !>
3877 : !> \author
3878 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3879 : interface getStrUpper
3880 :
3881 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3882 :
3883 : #if SK5_ENABLED
3884 : pure elemental module function getStrUpper_SK5(str) result(strUpper)
3885 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3886 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrUpper_SK5
3887 : #endif
3888 : use pm_kind, only: SKC => SK5
3889 : character(*,SKC) , intent(in) :: str
3890 : character(len(str,IK),SKC) :: strUpper
3891 : end function
3892 : #endif
3893 :
3894 : #if SK4_ENABLED
3895 : pure elemental module function getStrUpper_SK4(str) result(strUpper)
3896 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3897 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrUpper_SK4
3898 : #endif
3899 : use pm_kind, only: SKC => SK4
3900 : character(*,SKC) , intent(in) :: str
3901 : character(len(str,IK),SKC) :: strUpper
3902 : end function
3903 : #endif
3904 :
3905 : #if SK3_ENABLED
3906 : pure elemental module function getStrUpper_SK3(str) result(strUpper)
3907 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3908 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrUpper_SK3
3909 : #endif
3910 : use pm_kind, only: SKC => SK3
3911 : character(*,SKC) , intent(in) :: str
3912 : character(len(str,IK),SKC) :: strUpper
3913 : end function
3914 : #endif
3915 :
3916 : #if SK2_ENABLED
3917 : pure elemental module function getStrUpper_SK2(str) result(strUpper)
3918 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3919 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrUpper_SK2
3920 : #endif
3921 : use pm_kind, only: SKC => SK2
3922 : character(*,SKC) , intent(in) :: str
3923 : character(len(str,IK),SKC) :: strUpper
3924 : end function
3925 : #endif
3926 :
3927 : #if SK1_ENABLED
3928 : pure elemental module function getStrUpper_SK1(str) result(strUpper)
3929 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3930 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrUpper_SK1
3931 : #endif
3932 : use pm_kind, only: SKC => SK1
3933 : character(*,SKC) , intent(in) :: str
3934 : character(len(str,IK),SKC) :: strUpper
3935 : end function
3936 : #endif
3937 :
3938 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3939 :
3940 : end interface
3941 :
3942 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3943 :
3944 : !> \brief
3945 : !> Replace all lowercase English alphabets in the input string with the corresponding uppercase English letters.<br>
3946 : !>
3947 : !> \param[inout] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
3948 : !> On output, all instances of lowercase English letters will be replaced with the corresponding uppercase letters.<br>
3949 : !>
3950 : !> \interface{setStrUpper}
3951 : !> \code{.F90}
3952 : !>
3953 : !> use pm_strASCII, only: setStrUpper
3954 : !>
3955 : !> call setStrUpper(str)
3956 : !>
3957 : !> \endcode
3958 : !>
3959 : !> \pure
3960 : !>
3961 : !> \elemental
3962 : !>
3963 : !> \see
3964 : !> [setStrUpper](@ref pm_strASCII::setStrUpper)<br>
3965 : !> [setStrUpper](@ref pm_strASCII::setStrUpper)<br>
3966 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
3967 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
3968 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
3969 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
3970 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
3971 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
3972 : !>
3973 : !> \example{setStrUpper}
3974 : !> \include{lineno} example/pm_strASCII/setStrUpper/main.F90
3975 : !> \compilef{setStrUpper}
3976 : !> \output{setStrUpper}
3977 : !> \include{lineno} example/pm_strASCII/setStrUpper/main.out.F90
3978 : !>
3979 : !> \test
3980 : !> [test_pm_strASCII](@ref test_pm_strASCII)
3981 : !>
3982 : !> \finmain
3983 : !>
3984 : !> \author
3985 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
3986 : interface setStrUpper
3987 :
3988 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
3989 :
3990 : #if SK5_ENABLED
3991 : pure elemental module subroutine setStrUpper_SK5(str)
3992 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
3993 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrUpper_SK5
3994 : #endif
3995 : use pm_kind, only: SKC => SK5
3996 : character(*,SKC) , intent(inout) :: str
3997 : end subroutine
3998 : #endif
3999 :
4000 : #if SK4_ENABLED
4001 : pure elemental module subroutine setStrUpper_SK4(str)
4002 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4003 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrUpper_SK4
4004 : #endif
4005 : use pm_kind, only: SKC => SK4
4006 : character(*,SKC) , intent(inout) :: str
4007 : end subroutine
4008 : #endif
4009 :
4010 : #if SK3_ENABLED
4011 : pure elemental module subroutine setStrUpper_SK3(str)
4012 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4013 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrUpper_SK3
4014 : #endif
4015 : use pm_kind, only: SKC => SK3
4016 : character(*,SKC) , intent(inout) :: str
4017 : end subroutine
4018 : #endif
4019 :
4020 : #if SK2_ENABLED
4021 : pure elemental module subroutine setStrUpper_SK2(str)
4022 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4023 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrUpper_SK2
4024 : #endif
4025 : use pm_kind, only: SKC => SK2
4026 : character(*,SKC) , intent(inout) :: str
4027 : end subroutine
4028 : #endif
4029 :
4030 : #if SK1_ENABLED
4031 : pure elemental module subroutine setStrUpper_SK1(str)
4032 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4033 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrUpper_SK1
4034 : #endif
4035 : use pm_kind, only: SKC => SK1
4036 : character(*,SKC) , intent(inout) :: str
4037 : end subroutine
4038 : #endif
4039 :
4040 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4041 :
4042 : end interface
4043 :
4044 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4045 :
4046 : !> \brief
4047 : !> Generate and return the input string where the uppercase English alphabets are all converted to lowercase letters.<br>
4048 : !>
4049 : !> \param[in] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
4050 : !>
4051 : !> \return
4052 : !> `strLower` : The output scalar or array of the same type, kind, and rank as the input `str` containing
4053 : !> the input string where the uppercase English alphabets are all converted to lowercase letters.<br>
4054 : !>
4055 : !> \interface{getStrLower}
4056 : !> \code{.F90}
4057 : !>
4058 : !> use pm_strASCII, only: getStrLower
4059 : !> character(len(str,IK),kind(str)) :: strLower(size(str))
4060 : !>
4061 : !> strLower = getStrLower(str)
4062 : !>
4063 : !> \endcode
4064 : !>
4065 : !> \pure
4066 : !>
4067 : !> \elemental
4068 : !>
4069 : !> \see
4070 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
4071 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4072 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
4073 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4074 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
4075 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
4076 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
4077 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
4078 : !>
4079 : !> \example{getStrLower}
4080 : !> \include{lineno} example/pm_strASCII/getStrLower/main.F90
4081 : !> \compilef{getStrLower}
4082 : !> \output{getStrLower}
4083 : !> \include{lineno} example/pm_strASCII/getStrLower/main.out.F90
4084 : !>
4085 : !> \test
4086 : !> [test_pm_strASCII](@ref test_pm_strASCII)
4087 : !>
4088 : !> \finmain
4089 : !>
4090 : !> \author
4091 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
4092 : interface getStrLower
4093 :
4094 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4095 :
4096 : #if SK5_ENABLED
4097 : pure elemental module function getStrLower_SK5(str) result(strLower)
4098 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4099 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrLower_SK5
4100 : #endif
4101 : use pm_kind, only: SKC => SK5
4102 : character(*,SKC) , intent(in) :: str
4103 : character(len(str,IK),SKC) :: strLower
4104 : end function
4105 : #endif
4106 :
4107 : #if SK4_ENABLED
4108 : pure elemental module function getStrLower_SK4(str) result(strLower)
4109 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4110 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrLower_SK4
4111 : #endif
4112 : use pm_kind, only: SKC => SK4
4113 : character(*,SKC) , intent(in) :: str
4114 : character(len(str,IK),SKC) :: strLower
4115 : end function
4116 : #endif
4117 :
4118 : #if SK3_ENABLED
4119 : pure elemental module function getStrLower_SK3(str) result(strLower)
4120 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4121 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrLower_SK3
4122 : #endif
4123 : use pm_kind, only: SKC => SK3
4124 : character(*,SKC) , intent(in) :: str
4125 : character(len(str,IK),SKC) :: strLower
4126 : end function
4127 : #endif
4128 :
4129 : #if SK2_ENABLED
4130 : pure elemental module function getStrLower_SK2(str) result(strLower)
4131 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4132 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrLower_SK2
4133 : #endif
4134 : use pm_kind, only: SKC => SK2
4135 : character(*,SKC) , intent(in) :: str
4136 : character(len(str,IK),SKC) :: strLower
4137 : end function
4138 : #endif
4139 :
4140 : #if SK1_ENABLED
4141 : pure elemental module function getStrLower_SK1(str) result(strLower)
4142 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4143 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrLower_SK1
4144 : #endif
4145 : use pm_kind, only: SKC => SK1
4146 : character(*,SKC) , intent(in) :: str
4147 : character(len(str,IK),SKC) :: strLower
4148 : end function
4149 : #endif
4150 :
4151 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4152 :
4153 : end interface
4154 :
4155 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4156 :
4157 : !> \brief
4158 : !> Replace all uppercase English alphabets in the input string with the corresponding lowercase English letters.<br>
4159 : !>
4160 : !> \param[inout] str : The input scalar or array of arbitrary rank of type `character` of kind \SKALL.<br>
4161 : !> On output, all instances of uppercase English letters will be replaced with the corresponding lowercase letters.<br>
4162 : !>
4163 : !> \interface{setStrLower}
4164 : !> \code{.F90}
4165 : !>
4166 : !> use pm_strASCII, only: setStrLower
4167 : !>
4168 : !> call setStrLower(str)
4169 : !>
4170 : !> \endcode
4171 : !>
4172 : !> \pure
4173 : !>
4174 : !> \elemental
4175 : !>
4176 : !> \see
4177 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4178 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4179 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
4180 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4181 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
4182 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
4183 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
4184 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
4185 : !>
4186 : !> \example{setStrLower}
4187 : !> \include{lineno} example/pm_strASCII/setStrLower/main.F90
4188 : !> \compilef{setStrLower}
4189 : !> \output{setStrLower}
4190 : !> \include{lineno} example/pm_strASCII/setStrLower/main.out.F90
4191 : !>
4192 : !> \test
4193 : !> [test_pm_strASCII](@ref test_pm_strASCII)
4194 : !>
4195 : !> \finmain
4196 : !>
4197 : !> \author
4198 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
4199 : interface setStrLower
4200 :
4201 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4202 :
4203 : #if SK5_ENABLED
4204 : pure elemental module subroutine setStrLower_SK5(str)
4205 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4206 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrLower_SK5
4207 : #endif
4208 : use pm_kind, only: SKC => SK5
4209 : character(*,SKC) , intent(inout) :: str
4210 : end subroutine
4211 : #endif
4212 :
4213 : #if SK4_ENABLED
4214 : pure elemental module subroutine setStrLower_SK4(str)
4215 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4216 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrLower_SK4
4217 : #endif
4218 : use pm_kind, only: SKC => SK4
4219 : character(*,SKC) , intent(inout) :: str
4220 : end subroutine
4221 : #endif
4222 :
4223 : #if SK3_ENABLED
4224 : pure elemental module subroutine setStrLower_SK3(str)
4225 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4226 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrLower_SK3
4227 : #endif
4228 : use pm_kind, only: SKC => SK3
4229 : character(*,SKC) , intent(inout) :: str
4230 : end subroutine
4231 : #endif
4232 :
4233 : #if SK2_ENABLED
4234 : pure elemental module subroutine setStrLower_SK2(str)
4235 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4236 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrLower_SK2
4237 : #endif
4238 : use pm_kind, only: SKC => SK2
4239 : character(*,SKC) , intent(inout) :: str
4240 : end subroutine
4241 : #endif
4242 :
4243 : #if SK1_ENABLED
4244 : pure elemental module subroutine setStrLower_SK1(str)
4245 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4246 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrLower_SK1
4247 : #endif
4248 : use pm_kind, only: SKC => SK1
4249 : character(*,SKC) , intent(inout) :: str
4250 : end subroutine
4251 : #endif
4252 :
4253 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4254 :
4255 : end interface
4256 :
4257 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4258 :
4259 : !> \brief
4260 : !> Generate and return the input string quoted with double-quotation marks where all
4261 : !> instances of double-quotations within the input string are escaped in the Fortran-style.<br>
4262 : !>
4263 : !> \details
4264 : !> The Fortran-style quotation escaping is done by duplicating each quotation mark within the string.<br>
4265 : !>
4266 : !> \param[in] str : The input scalar of type `character` of kind \SKALL containing the string to be quoted.<br>
4267 : !>
4268 : !> \return
4269 : !> `strQuoted` : The output `allocatable` scalar or array of the same type, kind, and rank as the input `str` containing
4270 : !> the input string quoted with double-quotation marks where all instances of double-quotes are escaped.<br>
4271 : !>
4272 : !> \interface{getStrQuoted}
4273 : !> \code{.F90}
4274 : !>
4275 : !> use pm_strASCII, only: getStrQuoted
4276 : !> character(:,kind(str)), allocatable :: strQuoted(size(str))
4277 : !>
4278 : !> strQuoted = getStrQuoted(str)
4279 : !>
4280 : !> \endcode
4281 : !>
4282 : !> \pure
4283 : !>
4284 : !> \see
4285 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
4286 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4287 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
4288 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4289 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
4290 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
4291 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
4292 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
4293 : !>
4294 : !> \example{getStrQuoted}
4295 : !> \include{lineno} example/pm_strASCII/getStrQuoted/main.F90
4296 : !> \compilef{getStrQuoted}
4297 : !> \output{getStrQuoted}
4298 : !> \include{lineno} example/pm_strASCII/getStrQuoted/main.out.F90
4299 : !>
4300 : !> \test
4301 : !> [test_pm_strASCII](@ref test_pm_strASCII)<br>
4302 : !>
4303 : !> \todo
4304 : !> \pmed This generic interface can be extended to include an optional argument `delim` of type
4305 : !> `character(1,SKC)` that contains the user-specified quotation mark (other than double-quote).<br>
4306 : !>
4307 : !> \finmain
4308 : !>
4309 : !> \author
4310 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
4311 : interface getStrQuoted
4312 :
4313 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4314 :
4315 : #if SK5_ENABLED
4316 : pure module function getStrQuoted_SK5(str) result(strQuoted)
4317 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4318 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrQuoted_SK5
4319 : #endif
4320 : use pm_kind, only: SKC => SK5
4321 : character(*,SKC) , intent(in) :: str
4322 : character(:,SKC) , allocatable :: strQuoted
4323 : end function
4324 : #endif
4325 :
4326 : #if SK4_ENABLED
4327 : pure module function getStrQuoted_SK4(str) result(strQuoted)
4328 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4329 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrQuoted_SK4
4330 : #endif
4331 : use pm_kind, only: SKC => SK4
4332 : character(*,SKC) , intent(in) :: str
4333 : character(:,SKC) , allocatable :: strQuoted
4334 : end function
4335 : #endif
4336 :
4337 : #if SK3_ENABLED
4338 : pure module function getStrQuoted_SK3(str) result(strQuoted)
4339 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4340 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrQuoted_SK3
4341 : #endif
4342 : use pm_kind, only: SKC => SK3
4343 : character(*,SKC) , intent(in) :: str
4344 : character(:,SKC) , allocatable :: strQuoted
4345 : end function
4346 : #endif
4347 :
4348 : #if SK2_ENABLED
4349 : pure module function getStrQuoted_SK2(str) result(strQuoted)
4350 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4351 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrQuoted_SK2
4352 : #endif
4353 : use pm_kind, only: SKC => SK2
4354 : character(*,SKC) , intent(in) :: str
4355 : character(:,SKC) , allocatable :: strQuoted
4356 : end function
4357 : #endif
4358 :
4359 : #if SK1_ENABLED
4360 : pure module function getStrQuoted_SK1(str) result(strQuoted)
4361 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4362 : !DEC$ ATTRIBUTES DLLEXPORT :: getStrQuoted_SK1
4363 : #endif
4364 : use pm_kind, only: SKC => SK1
4365 : character(*,SKC) , intent(in) :: str
4366 : character(:,SKC) , allocatable :: strQuoted
4367 : end function
4368 : #endif
4369 :
4370 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4371 :
4372 : end interface
4373 :
4374 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4375 :
4376 : !> \brief
4377 : !> Return the input string quoted with double-quotation marks where all
4378 : !> instances of double-quotations within the input string are escaped in the Fortran-style.<br>
4379 : !>
4380 : !> \details
4381 : !> The Fortran-style quotation escaping is done by duplicating each quotation mark within the string.<br>
4382 : !>
4383 : !> \param[out] strQuoted : The output `allocatable` scalar `character` of kind \SKALL containing the input string
4384 : !> quoted with double-quotation marks where all instances of double-quotes are escaped.<br>
4385 : !> \param[in] str : The input scalar of the same type and kind as `strQuoted`, of arbitrary length type parameter containing the string to be quoted.<br>
4386 : !>
4387 : !> \interface{setStrQuoted}
4388 : !> \code{.F90}
4389 : !>
4390 : !> use pm_strASCII, only: setStrQuoted
4391 : !>
4392 : !> call setStrQuoted(strQuoted, str)
4393 : !>
4394 : !> \endcode
4395 : !>
4396 : !> \pure
4397 : !>
4398 : !> \see
4399 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4400 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4401 : !> [getStrLower](@ref pm_strASCII::getStrLower)<br>
4402 : !> [setStrLower](@ref pm_strASCII::setStrLower)<br>
4403 : !> [isCharUpper](@ref pm_strASCII::isCharUpper)<br>
4404 : !> [isCharLower](@ref pm_strASCII::isCharLower)<br>
4405 : !> [isStrUpperAll](@ref pm_strASCII::isStrUpperAll)<br>
4406 : !> [isStrLowerAll](@ref pm_strASCII::isStrLowerAll)<br>
4407 : !>
4408 : !> \example{setStrQuoted}
4409 : !> \include{lineno} example/pm_strASCII/setStrQuoted/main.F90
4410 : !> \compilef{setStrQuoted}
4411 : !> \output{setStrQuoted}
4412 : !> \include{lineno} example/pm_strASCII/setStrQuoted/main.out.F90
4413 : !>
4414 : !> \test
4415 : !> [test_pm_strASCII](@ref test_pm_strASCII)
4416 : !>
4417 : !> \todo
4418 : !> \pmed This generic interface can be extended to include an optional argument `delim` of type
4419 : !> `character(1,SKC)` that contains the user-specified quotation mark (other than double-quote).<br>
4420 : !>
4421 : !> \finmain
4422 : !>
4423 : !> \author
4424 : !> \AmirShahmoradi, September 1, 2017, 12:00 AM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
4425 : interface setStrQuoted
4426 :
4427 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4428 :
4429 : #if SK5_ENABLED
4430 : pure module subroutine setStrQuoted_SK5(strQuoted, str)
4431 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4432 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrQuoted_SK5
4433 : #endif
4434 : use pm_kind, only: SKC => SK5
4435 : character(:,SKC) , intent(out) , allocatable :: strQuoted
4436 : character(*,SKC) , intent(in) :: str
4437 : end subroutine
4438 : #endif
4439 :
4440 : #if SK4_ENABLED
4441 : pure module subroutine setStrQuoted_SK4(strQuoted, str)
4442 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4443 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrQuoted_SK4
4444 : #endif
4445 : use pm_kind, only: SKC => SK4
4446 : character(:,SKC) , intent(out) , allocatable :: strQuoted
4447 : character(*,SKC) , intent(in) :: str
4448 : end subroutine
4449 : #endif
4450 :
4451 : #if SK3_ENABLED
4452 : pure module subroutine setStrQuoted_SK3(strQuoted, str)
4453 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4454 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrQuoted_SK3
4455 : #endif
4456 : use pm_kind, only: SKC => SK3
4457 : character(:,SKC) , intent(out) , allocatable :: strQuoted
4458 : character(*,SKC) , intent(in) :: str
4459 : end subroutine
4460 : #endif
4461 :
4462 : #if SK2_ENABLED
4463 : pure module subroutine setStrQuoted_SK2(strQuoted, str)
4464 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4465 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrQuoted_SK2
4466 : #endif
4467 : use pm_kind, only: SKC => SK2
4468 : character(:,SKC) , intent(out) , allocatable :: strQuoted
4469 : character(*,SKC) , intent(in) :: str
4470 : end subroutine
4471 : #endif
4472 :
4473 : #if SK1_ENABLED
4474 : pure module subroutine setStrQuoted_SK1(strQuoted, str)
4475 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4476 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrQuoted_SK1
4477 : #endif
4478 : use pm_kind, only: SKC => SK1
4479 : character(:,SKC) , intent(out) , allocatable :: strQuoted
4480 : character(*,SKC) , intent(in) :: str
4481 : end subroutine
4482 : #endif
4483 :
4484 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4485 :
4486 : end interface
4487 :
4488 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4489 :
4490 : !> \brief
4491 : !> Generate and return the input C-style escaped string where all instances of C-style escape sequences
4492 : !> are converted to the corresponding ASCII characters or left intact if they are not convertible.<br>
4493 : !>
4494 : !> \details
4495 : !> See the documentation of [setAsciiFromEscaped](@ref pm_strASCII::setAsciiFromEscaped) for further details.<br>
4496 : !>
4497 : !> \param[in] str : The input scalar `character` of kind \SKALL containing the C-style escaped string to be converted to ASCII.<br>
4498 : !>
4499 : !> \return
4500 : !> `ascii` : The output `allocatable` scalar of the same type and kind as the input `str` containing
4501 : !> the input string where all instances of escape seuquences with an ASCII representation are
4502 : !> replaced with their corresponding ASCII character (, otherwise, left as is).<br>
4503 : !>
4504 : !> \interface{getAsciiFromEscaped}
4505 : !> \code{.F90}
4506 : !>
4507 : !> use pm_strASCII, only: getAsciiFromEscaped
4508 : !> character(:,kind(str)), allocatable :: ascii
4509 : !>
4510 : !> ascii = getAsciiFromEscaped(str)
4511 : !>
4512 : !> \endcode
4513 : !>
4514 : !> \warnpure
4515 : !> The impurity of the procedures is caused by the dependence on other conditionally `impure` procedure.<br>
4516 : !>
4517 : !> \see
4518 : !> [setAsciiFromEscaped](@ref pm_strASCII::setAsciiFromEscaped)<br>
4519 : !> [isFailedList](@ref pm_sysPath::isFailedList)<br>
4520 : !>
4521 : !> \example{getAsciiFromEscaped}
4522 : !> \include{lineno} example/pm_strASCII/getAsciiFromEscaped/main.F90
4523 : !> \compilef{getAsciiFromEscaped}
4524 : !> \output{getAsciiFromEscaped}
4525 : !> \include{lineno} example/pm_strASCII/getAsciiFromEscaped/main.out.F90
4526 : !>
4527 : !> \test
4528 : !> [test_pm_strASCII](@ref test_pm_strASCII)
4529 : !>
4530 : !> \finmain
4531 : !>
4532 : !> \author
4533 : !> \AmirShahmoradi, September 1, 2017, 11:02 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
4534 : interface getAsciiFromEscaped
4535 :
4536 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4537 :
4538 : #if SK5_ENABLED
4539 : PURE module function getAsciiFromEscapedNew_SK5(str) result(ascii)
4540 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4541 : !DEC$ ATTRIBUTES DLLEXPORT :: getAsciiFromEscapedNew_SK5
4542 : #endif
4543 : use pm_kind, only: SKC => SK5
4544 : character(*,SKC) , intent(in) :: str
4545 : character(:,SKC) , allocatable :: ascii
4546 : end function
4547 : #endif
4548 :
4549 : #if SK4_ENABLED
4550 : PURE module function getAsciiFromEscapedNew_SK4(str) result(ascii)
4551 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4552 : !DEC$ ATTRIBUTES DLLEXPORT :: getAsciiFromEscapedNew_SK4
4553 : #endif
4554 : use pm_kind, only: SKC => SK4
4555 : character(*,SKC) , intent(in) :: str
4556 : character(:,SKC) , allocatable :: ascii
4557 : end function
4558 : #endif
4559 :
4560 : #if SK3_ENABLED
4561 : PURE module function getAsciiFromEscapedNew_SK3(str) result(ascii)
4562 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4563 : !DEC$ ATTRIBUTES DLLEXPORT :: getAsciiFromEscapedNew_SK3
4564 : #endif
4565 : use pm_kind, only: SKC => SK3
4566 : character(*,SKC) , intent(in) :: str
4567 : character(:,SKC) , allocatable :: ascii
4568 : end function
4569 : #endif
4570 :
4571 : #if SK2_ENABLED
4572 : PURE module function getAsciiFromEscapedNew_SK2(str) result(ascii)
4573 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4574 : !DEC$ ATTRIBUTES DLLEXPORT :: getAsciiFromEscapedNew_SK2
4575 : #endif
4576 : use pm_kind, only: SKC => SK2
4577 : character(*,SKC) , intent(in) :: str
4578 : character(:,SKC) , allocatable :: ascii
4579 : end function
4580 : #endif
4581 :
4582 : #if SK1_ENABLED
4583 : PURE module function getAsciiFromEscapedNew_SK1(str) result(ascii)
4584 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4585 : !DEC$ ATTRIBUTES DLLEXPORT :: getAsciiFromEscapedNew_SK1
4586 : #endif
4587 : use pm_kind, only: SKC => SK1
4588 : character(*,SKC) , intent(in) :: str
4589 : character(:,SKC) , allocatable :: ascii
4590 : end function
4591 : #endif
4592 :
4593 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4594 :
4595 : end interface
4596 :
4597 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4598 :
4599 : !> \brief
4600 : !> Return the input C-style escaped string where all instances of C-style escape sequences
4601 : !> are converted to the corresponding ASCII characters or left intact if they are not convertible.<br>
4602 : !>
4603 : !> \details
4604 : !> Escape sequences are used in the programming languages C and C++ whose conventions are also followed by many other languages.<br>
4605 : !> An **escape sequence** is a sequence of characters that does not represent itself when used inside a character or string literal.<br>
4606 : !> Instead, it is translated into another character or a sequence of characters that may be difficult or impossible to represent directly.<br>
4607 : !> In C, all escape sequences consist of two or more characters, the first of which is the backslash, `\` (called the **escape character**).<br>
4608 : !> The remaining characters determine the interpretation of the escape sequence. For example, `\n` is an escape sequence that denotes a newline character.<br>
4609 : !> The following escape sequences are defined in standard C which commonly (but not always) represent an ASCII (frequently nongraphical) character:<br>
4610 : !>
4611 : !> Escape sequence | ASCII Octal | ASCII Decimal | ASCII Hex | ASCII Character Representation
4612 : !> ------------------------|---------------|-------------------|---------------|------------------------------------
4613 : !> \f$\ms{\a}\f$ | 07 | 07 | 07 | Alert (Beep, Bell) (added in C89)
4614 : !> \f$\ms{\b}\f$ | 10 | 08 | 08 | Backspace
4615 : !> \f$\ms{\f}\f$ | 14 | 12 | 0C | Formfeed Page Break
4616 : !> \f$\ms{\n}\f$ | 12 | 10 | 0A | Newline (Line Feed)
4617 : !> \f$\ms{\r}\f$ | 15 | 13 | 0D | Carriage Return
4618 : !> \f$\ms{\t}\f$ | 11 | 09 | 09 | Horizontal Tab
4619 : !> \f$\ms{\v}\f$ | 13 | 11 | 0B | Vertical Tab
4620 : !> \f$\ms{\\}\f$ | 134 | 92 | 5C | Backslash
4621 : !> \f$\ms{\'}\f$ | 47 | 39 | 27 | Apostrophe or single quotation mark
4622 : !> \f$\ms{\"}\f$ | 42 | 34 | 22 | Double quotation mark
4623 : !> \f$\ms{\?}\f$ | 77 | 63 | 3F | Question mark (used to avoid trigraphs)
4624 : !> \f$\ms{\nnn}\f$ | any | any | any | The byte whose numerical value is given by `nnn` interpreted as an **octal number**
4625 : !> \f$\ms{\xhh…}\f$ | any | any | any | The byte whose numerical value is given by `hh…` interpreted as a **hexadecimal number**
4626 : !> \f$\ms{\uhhhh}\f$ | none | none | none | Unicode code point below **10000 hexadecimal** (added in C99)
4627 : !> \f$\ms{\Uhhhhhhhh}\f$ | none | none | none | Unicode code point where `h` is a **hexadecimal digit**
4628 : !>
4629 : !> The following remarks are in order:
4630 : !>
4631 : !> Octal Escape Sequences
4632 : !> ----------------------
4633 : !>
4634 : !> An **octal escape sequence** consists of `\` followed by **one, two, or three** octal digits.<br>
4635 : !> <ol>
4636 : !> <li> The octal escape sequence ends when it either contains three octal digits already, or the next character is not an octal digit.<br>
4637 : !> For example,
4638 : !> <ol>
4639 : !> <li> `\11` is a single octal escape sequence denoting a byte with numerical value `9` (`11` in octal), rather than the escape sequence `\1` followed by the digit `1`.<br>
4640 : !> <li> However, `\1111` is the octal escape sequence `\111` followed by the digit `1`.<br>
4641 : !> </ol>
4642 : !> <li> In order to denote the byte with numerical value `1`, followed by the digit `1`, one could use `"\1""1"`, since C automatically concatenates adjacent string literals.<br>
4643 : !> <li> Some three-digit octal escape sequences may be too large to fit in a single byte.<br>
4644 : !> This results in an implementation-defined value for the byte actually produced.<br>
4645 : !> <li> The escape sequence `\0` is a commonly used octal escape sequence, which denotes the **null character**, with value zero.<br>
4646 : !> <li> The procedures of this generic interface leave any octal sequence that is non-convertible to ASCII character intact (as is) in the output.<br>
4647 : !> </ol>
4648 : !>
4649 : !> Hex Escape Sequences
4650 : !> --------------------
4651 : !>
4652 : !> A **hex escape sequence** must have **at least one hex digit** following `\x`, with no upper bound.<br>
4653 : !> <ol>
4654 : !> <li> It continues for as many hex digits as there are.<br>
4655 : !> For example, `\xABCDEFG` denotes the byte with the numerical value `ABCDEF16`, followed by the letter `G`, which is not a hex digit.<br>
4656 : !> <li> However, if the resulting integer value is too large to fit in a single byte, the actual numerical value assigned is implementation-defined.<br>
4657 : !> Most platforms have `8`-bit character types, which limits a useful hex escape sequence to **two hex digits**.<br>
4658 : !> However, hex escape sequences longer than two hex digits might be useful inside a wide character or wide string.<br>
4659 : !> <li> The procedures of this generic interface leave any hex sequence that is non-convertible to ASCII character intact (as is) in the output.<br>
4660 : !> <li> The Hex alphabetical digits, if any are present, must be upper-case letters.<br>
4661 : !> </ol>
4662 : !>
4663 : !> Universal Character Names
4664 : !> -------------------------
4665 : !>
4666 : !> The C99 standard also supports escape sequences that denote Unicode code points in string literals.<br>
4667 : !> Such escape sequences are called **universal character names** and have the form `\uhhhh` or `\Uhhhhhhhh`, where `h` stands for a hex digit.<br>
4668 : !> <ol>
4669 : !> <li> **Unlike** other escape sequences considered, a universal character name may expand into more than one code unit.<br>
4670 : !> <li> The sequence `\uhhhh` denotes the code point `hhhh`, interpreted as a **hexadecimal number**.<br>
4671 : !> <li> The sequence `\Uhhhhhhhh` denotes the code point `hhhhhhhh`, interpreted as a **hexadecimal number**.<br>
4672 : !> <li> The code points located at `U+10000` or higher must be denoted with the `\U` syntax, whereas lower code points may use `\u` or `\U`.<br>
4673 : !> <li> The code point is converted into a sequence of code units in the encoding of the destination type on the target system.<br>
4674 : !> <li> The procedures of this generic interface leave any UCN that is non-convertible to ASCII character intact (as is) in the output.<br>
4675 : !> <li> The Hex alphabetical digits in the UCN, if any are present, must be upper-case letters.<br>
4676 : !> </ol>
4677 : !>
4678 : !> This functionality of this generic interface is highly useful for handling and maniulating C-style strings,
4679 : !> for example, in processing the output of runtime shell commands, or processing user-specified strings that
4680 : !> may or should contain nongraphical ASCII characters in a portable way.<br>
4681 : !>
4682 : !> \param[inout] str : The scalar `character` of kind \SKALL containing the C-style escaped string to be converted to ASCII.<br>
4683 : !> -# If the output argument `ascii` is present, then `str` has `intent(in)` attribute.<br>
4684 : !> -# If the output argument `ascii` is missing, then `str` has `intent(inout)` attribute.<br>
4685 : !> On output, the contents of `str(1:endloc)` will be overwritten with the ASCII equivalent.<br>
4686 : !> \param[out] ascii : The output scalar of the same type and kind as the input `str` of length type parameter equal
4687 : !> to or larger than the length of `str`, containing the input string where all instances of escape
4688 : !> seuquences with an ASCII representation are replaced with their corresponding ASCII character.<br>
4689 : !> (**optional**. If missing, the output ASCII will be written to `str`.)
4690 : !> \param[out] endloc : The output scalar of type `integer` of default kind \IK, containing the position of
4691 : !> the last character of the resulting ASCII-converted string (in either `str` or `ascii`).<br>
4692 : !>
4693 : !> \interface{setAsciiFromEscaped}
4694 : !> \code{.F90}
4695 : !>
4696 : !> use pm_kind, only: IK
4697 : !> use pm_strASCII, only: setAsciiFromEscaped
4698 : !> character(len(str,IK), kind(str)) :: ascii
4699 : !> integer(IK) :: endloc
4700 : !>
4701 : !> call setAsciiFromEscaped(str, endloc)
4702 : !> call setAsciiFromEscaped(str, ascii, endloc)
4703 : !>
4704 : !> \endcode
4705 : !>
4706 : !> \warnpure
4707 : !> The impurity of the procedures is caused by the dependence on other conditionally `impure` procedure.<br>
4708 : !>
4709 : !> \note
4710 : !> Returning the output inside the input `str` should generally lead to faster runtime performance.<br>
4711 : !>
4712 : !> \see
4713 : !> [getAsciiFromEscaped](@ref pm_strASCII::getAsciiFromEscaped)<br>
4714 : !> [isFailedList](@ref pm_sysPath::isFailedList)<br>
4715 : !>
4716 : !> \example{setAsciiFromEscaped}
4717 : !> \include{lineno} example/pm_strASCII/setAsciiFromEscaped/main.F90
4718 : !> \compilef{setAsciiFromEscaped}
4719 : !> \output{setAsciiFromEscaped}
4720 : !> \include{lineno} example/pm_strASCII/setAsciiFromEscaped/main.out.F90
4721 : !>
4722 : !> \test
4723 : !> [test_pm_strASCII](@ref test_pm_strASCII)
4724 : !>
4725 : !> \todo
4726 : !> \phigh
4727 : !> A performance benchmarking of the different interfaces of this generic interface should be added in the future.<br>
4728 : !>
4729 : !> \finmain
4730 : !>
4731 : !> \author
4732 : !> \AmirShahmoradi, September 1, 2017, 11:02 PM, Institute for Computational Engineering and Sciences (ICES), The University of Texas at Austin
4733 : interface setAsciiFromEscaped
4734 :
4735 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4736 :
4737 : #if SK5_ENABLED
4738 : PURE module subroutine setAsciiFromEscapedRep_SK5(str, endloc)
4739 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4740 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedRep_SK5
4741 : #endif
4742 : use pm_kind, only: SKC => SK5
4743 : character(*,SKC) , intent(inout) :: str
4744 : integer(IK) , intent(out) :: endloc
4745 : end subroutine
4746 : #endif
4747 :
4748 : #if SK4_ENABLED
4749 : PURE module subroutine setAsciiFromEscapedRep_SK4(str, endloc)
4750 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4751 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedRep_SK4
4752 : #endif
4753 : use pm_kind, only: SKC => SK4
4754 : character(*,SKC) , intent(inout) :: str
4755 : integer(IK) , intent(out) :: endloc
4756 : end subroutine
4757 : #endif
4758 :
4759 : #if SK3_ENABLED
4760 : PURE module subroutine setAsciiFromEscapedRep_SK3(str, endloc)
4761 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4762 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedRep_SK3
4763 : #endif
4764 : use pm_kind, only: SKC => SK3
4765 : character(*,SKC) , intent(inout) :: str
4766 : integer(IK) , intent(out) :: endloc
4767 : end subroutine
4768 : #endif
4769 :
4770 : #if SK2_ENABLED
4771 : PURE module subroutine setAsciiFromEscapedRep_SK2(str, endloc)
4772 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4773 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedRep_SK2
4774 : #endif
4775 : use pm_kind, only: SKC => SK2
4776 : character(*,SKC) , intent(inout) :: str
4777 : integer(IK) , intent(out) :: endloc
4778 : end subroutine
4779 : #endif
4780 :
4781 : #if SK1_ENABLED
4782 : PURE module subroutine setAsciiFromEscapedRep_SK1(str, endloc)
4783 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4784 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedRep_SK1
4785 : #endif
4786 : use pm_kind, only: SKC => SK1
4787 : character(*,SKC) , intent(inout) :: str
4788 : integer(IK) , intent(out) :: endloc
4789 : end subroutine
4790 : #endif
4791 :
4792 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4793 :
4794 : #if SK5_ENABLED
4795 : PURE module subroutine setAsciiFromEscapedNew_SK5(str, ascii, endloc)
4796 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4797 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedNew_SK5
4798 : #endif
4799 : use pm_kind, only: SKC => SK5
4800 : character(*,SKC) , intent(in) :: str
4801 : character(*,SKC) , intent(out) :: ascii
4802 : integer(IK) , intent(out) :: endloc
4803 : end subroutine
4804 : #endif
4805 :
4806 : #if SK4_ENABLED
4807 : PURE module subroutine setAsciiFromEscapedNew_SK4(str, ascii, endloc)
4808 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4809 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedNew_SK4
4810 : #endif
4811 : use pm_kind, only: SKC => SK4
4812 : character(*,SKC) , intent(in) :: str
4813 : character(*,SKC) , intent(out) :: ascii
4814 : integer(IK) , intent(out) :: endloc
4815 : end subroutine
4816 : #endif
4817 :
4818 : #if SK3_ENABLED
4819 : PURE module subroutine setAsciiFromEscapedNew_SK3(str, ascii, endloc)
4820 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4821 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedNew_SK3
4822 : #endif
4823 : use pm_kind, only: SKC => SK3
4824 : character(*,SKC) , intent(in) :: str
4825 : character(*,SKC) , intent(out) :: ascii
4826 : integer(IK) , intent(out) :: endloc
4827 : end subroutine
4828 : #endif
4829 :
4830 : #if SK2_ENABLED
4831 : PURE module subroutine setAsciiFromEscapedNew_SK2(str, ascii, endloc)
4832 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4833 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedNew_SK2
4834 : #endif
4835 : use pm_kind, only: SKC => SK2
4836 : character(*,SKC) , intent(in) :: str
4837 : character(*,SKC) , intent(out) :: ascii
4838 : integer(IK) , intent(out) :: endloc
4839 : end subroutine
4840 : #endif
4841 :
4842 : #if SK1_ENABLED
4843 : PURE module subroutine setAsciiFromEscapedNew_SK1(str, ascii, endloc)
4844 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4845 : !DEC$ ATTRIBUTES DLLEXPORT :: setAsciiFromEscapedNew_SK1
4846 : #endif
4847 : use pm_kind, only: SKC => SK1
4848 : character(*,SKC) , intent(in) :: str
4849 : character(*,SKC) , intent(out) :: ascii
4850 : integer(IK) , intent(out) :: endloc
4851 : end subroutine
4852 : #endif
4853 :
4854 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4855 :
4856 : end interface
4857 :
4858 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4859 :
4860 : contains
4861 :
4862 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4863 :
4864 : !> \cond excluded
4865 0 : impure elemental subroutine setStrAlphaRand(strAlphaRand)
4866 : #if __INTEL_COMPILER && DLL_ENABLED && (_WIN32 || _WIN64)
4867 : !DEC$ ATTRIBUTES DLLEXPORT :: setStrAlphaRand
4868 : #endif
4869 : use pm_kind, only: SK, IK
4870 : character(*, SK), intent(inout) :: strAlphaRand
4871 : integer(IK) , parameter :: BOUND_LOWER_CASE_L = ichar("a", kind = IK)
4872 : integer(IK) , parameter :: BOUND_UPPER_CASE_L = ichar("z", kind = IK)
4873 : integer(IK) , parameter :: BOUND_LOWER_CASE_U = ichar("A", kind = IK)
4874 : integer(IK) , parameter :: BOUND_UPPER_CASE_U = ichar("Z", kind = IK)
4875 : real :: randUnif, randUnifUL
4876 : integer(IK) :: i
4877 0 : do i = 1, len(strAlphaRand, IK)
4878 0 : call random_number(randUnifUL)
4879 0 : call random_number(randUnif)
4880 0 : if (randUnifUL < 0.5) then
4881 0 : strAlphaRand(i:i) = char( BOUND_LOWER_CASE_L + floor(randUnif * (BOUND_UPPER_CASE_L - BOUND_LOWER_CASE_L + 1_IK)) )
4882 : else
4883 0 : strAlphaRand(i:i) = char( BOUND_LOWER_CASE_U + floor(randUnif * (BOUND_UPPER_CASE_U - BOUND_LOWER_CASE_U + 1_IK)) )
4884 : end if
4885 : end do
4886 0 : end subroutine setStrAlphaRand
4887 : !> \endcond excluded
4888 :
4889 : !%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
4890 :
4891 : end module pm_strASCII ! LCOV_EXCL_LINE
|
