Generate and return index, the index of the last element of the input array such that array(index+1:) contains only full repetitions of the user-specified pattern. More...

Detailed Description

Generate and return index, the index of the last element of the input array such that array(index+1:) contains only full repetitions of the user-specified pattern.

Parameters

[in]

array

: The input contiguous vector of either

type character of kind any supported by the processor (e.g., SK, SKA, SKD , or SKU), or
type logical of kind any supported by the processor (e.g., LK), or
type integer of kind any supported by the processor (e.g., IK, IK8, IK16, IK32, or IK64), or
type complex of kind any supported by the processor (e.g., CK, CK32, CK64, or CK128), or
type real of kind any supported by the processor (e.g., RK, RK32, RK64, or RK128),

or,

a scalar assumed-length character of kind any supported by the processor (e.g., SK, SKA, SKD , or SKU),

[in] pattern : The input object of the same type and kind as the input array, of rank similar to or lower than that of array, whose value is to be stripped from the beginning of array.

iseq

: The external user-specified function that takes either two input assumed-length character arguments (if the input array is also an assumed-length character) or two array-valued explicit-shape arguments of the same type and kind as the input array.
It must return a scalar of type logical of default kind LK that is .true. if all elements of the two input arguments are equivalent (e.g., equal) according to the user-defined criterion, otherwise, it is .false..
The the input array is array-valued, then the last argument to iseq is the length of the input pattern.
The following illustrates the generic interface of iseq where pattern is array-valued,

function iseq(Segment, pattern, lenPattern) result(equivalent)
    use pm_kind, only: IK, LK
    integer(IK) , intent(in)    :: lenPattern
    TYPE(KIND)  , intent(in)    :: Segment(lenPattern), pattern(lenPattern)
    logical(LK)                 :: equivalent
end function

where TYPE(KIND) represents the type and kind of the input argument array, which can be one of the following,

character(*, SK), intent(in)    :: Segment(lenPattern), pattern(lenPattern)
integer(IK)     , intent(in)    :: Segment(lenPattern), pattern(lenPattern)
logical(LK)     , intent(in)    :: Segment(lenPattern), pattern(lenPattern)
complex(CK)     , intent(in)    :: Segment(lenPattern), pattern(lenPattern)
real(RK)        , intent(in)    :: Segment(lenPattern), pattern(lenPattern)

where the kinds SKG, IKG, LKG, CKG, RK, can refer to any kind type parameter that is supported by the processor.
The following illustrates the generic interface of iseq where pattern is scalar-valued (including Fortran scalar strings),

function iseq(segment, pattern) result(equivalent)
    use pm_kind, only: LK
    TYPE(KIND)  , intent(in)    :: segment, pattern
    logical(LK)                 :: equivalent
end function

where TYPE(KIND) represents the type and kind of the input argument array, which can be one of the following,

use pm_kind, only: SK, IK, LK, CK, RK
character(*, SK), intent(in)    :: segment, pattern
integer(IK)     , intent(in)    :: segment, pattern
logical(LK)     , intent(in)    :: segment, pattern
complex(CK)     , intent(in)    :: segment, pattern
real(RK)        , intent(in)    :: segment, pattern

where the kinds SK, IK, LK, CK, RK, can refer to any kind type parameter that is supported by the processor.
This user-defined equivalence check is extremely useful where an equivalence test other than exact identity is needed, for example, when the array segments should match the input pattern only within a given threshold or, when the case-sensitivity in character comparisons do not matter.
In such cases, user can define a custom equivalence criterion within the user-defined external function iseq to achieve the goal.
(optional, the default equivalence operator is .eqv. if the input array is logical, otherwise ==)

Returns: index : The output scalar integer of default kind IK representing the index of the last element of the input array such that array(index+1:) contains only full repetitions of the user-specified pattern .

Possible calling interfaces ⛓

: use pm_arrayStrip, only: getSIR

use pm_kind, only: IK

integer(IK) :: index

index = getSIR(array, pattern) ! scalar strings

index = getSIR(array(:), pattern) ! all intrinsic types

index = getSIR(array(:), pattern(:)) ! all intrinsic types

index = getSIR(array, pattern, iseq) ! scalar strings

index = getSIR(array(:), pattern, iseq) ! all intrinsic types

index = getSIR(array(:), pattern(:), iseq) ! all intrinsic types

!

pm_arrayStrip::getSIR
Generate and return index, the index of the last element of the input array such that array(index+1:)...
Definition: pm_arrayStrip.F90:6573

pm_arrayStrip
This module contains procedures and generic interfaces for stripping a given pattern from the left an...
Definition: pm_arrayStrip.F90:55

Warning: The procedures under this generic interface are impure when the user-specified external procedure iseq is specified as input argument.; Note that in Fortran, trailing blanks are ignored in character equivalence checks, that is, "Fortran" == "Fortran " yields .true..; The pure procedure(s) documented herein become impure when the ParaMonte library is compiled with preprocessor macro CHECK_ENABLED=1.
By default, these procedures are pure in release build and impure in debug and testing builds.

See also: getSIL
getSIR
getStripped
setReplaced
getReplaced
setInserted
setSplit
setLoc
getLoc

Example usage ⛓

: 1program example

2

3 use pm_kind, only: SK, IK, LK, CK, RK

4 use pm_io, only: display_type

5 use pm_arrayStrip, only: getSIR

6

7 implicit none

8

9 integer(IK) :: index

10

11 type(display_type) :: disp

12

13 disp = display_type(file = "main.out.F90")

14

15 call disp%skip()

16 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

17 call disp%show("! Strip pattern from the beginning of a string.")

18 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

19 call disp%skip()

20

21 block

22 character(:) , allocatable :: string, pattern

23

24 call disp%skip()

25 call disp%show("string = ''")

26 string = ''

27 call disp%show("pattern = ''")

28 pattern = ''

29 call disp%show("index = getSIR(string, pattern)")

30 index = getSIR(string, pattern)

31 call disp%show("string(:index)")

32 call disp%show( string(:index), deliml = """" )

33 call disp%show("index")

34 call disp%show( index )

35 call disp%skip()

36

37 call disp%skip()

38 call disp%show("string = 'bbaaa'")

39 string = 'bbaaa'

40 call disp%show("pattern = ''")

41 pattern = ''

42 call disp%show("index = getSIR(string, pattern)")

43 index = getSIR(string, pattern)

44 call disp%show("string(:index)")

45 call disp%show( string(:index), deliml = """" )

46 call disp%show("index")

47 call disp%show( index )

48 call disp%skip()

49

50 call disp%skip()

51 call disp%show("string = 'bbaaa'")

52 string = 'bbaaa'

53 call disp%show("pattern = 'a'")

54 pattern = 'a'

55 call disp%show("index = getSIR(string, pattern)")

56 index = getSIR(string, pattern)

57 call disp%show("string(:index)")

58 call disp%show( string(:index), deliml = """" )

59 call disp%show("index")

60 call disp%show( index )

61 call disp%skip()

62

63 call disp%skip()

64 call disp%show("string = 'bbaaa'")

65 string = 'bbaaa'

66 call disp%show("pattern = 'b'")

67 pattern = 'b'

68 call disp%show("index = getSIR(string, pattern)")

69 index = getSIR(string, pattern)

70 call disp%show("string(:index)")

71 call disp%show( string(:index), deliml = """" )

72 call disp%show("index")

73 call disp%show( index )

74 call disp%skip()

75

76 call disp%skip()

77 call disp%show("string = 'bbaaa'")

78 string = 'bbaaa'

79 call disp%show("pattern = 'bbaaa '")

80 pattern = 'bbaaa '

81 call disp%show("index = getSIR(string, pattern)")

82 index = getSIR(string, pattern)

83 call disp%show("string(:index)")

84 call disp%show( string(:index), deliml = """" )

85 call disp%show("index")

86 call disp%show( index )

87 call disp%skip()

88

89 call disp%skip()

90 call disp%show("string = 'bbAa'")

91 string = 'bbAa'

92 call disp%show("pattern = 'aa'")

93 pattern = 'aa'

94 call disp%show("index = getSIR(string, pattern)")

95 index = getSIR(string, pattern)

96 call disp%show("string(:index)")

97 call disp%show( string(:index), deliml = """" )

98 call disp%show("index")

99 call disp%show( index )

100 call disp%show("index = getSIR(string, pattern, iseqScalar_SK)")

101 index = getSIR(string, pattern, iseqScalar_SK)

102 call disp%show("string(:index)")

103 call disp%show( string(:index), deliml = """" )

104 call disp%show("index")

105 call disp%show( index )

106 call disp%skip()

107

108 end block

109

110 call disp%skip()

111 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

112 call disp%show("! Strip pattern from the beginning of a string array.")

113 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

114 call disp%skip()

115

116 block

117 character(2), allocatable :: Array(:)

118 character(:), allocatable :: scalarPattern

119 character(:), allocatable :: arrayPattern(:)

120

121 call disp%skip()

122 call disp%show("Array = [character(2) :: ]")

123 Array = [character(2) :: ]

124 call disp%show("scalarPattern = ''")

125 scalarPattern = ''

126 call disp%show("index = getSIR(Array, scalarPattern)")

127 index = getSIR(Array, scalarPattern)

128 call disp%show("Array(:index)")

129 call disp%show( Array(:index), deliml = """" )

130 call disp%show("index")

131 call disp%show( index )

132 call disp%skip()

133

134 call disp%skip()

135 call disp%show("Array = [character(2) :: ]")

136 Array = [character(2) :: ]

137 call disp%show("arrayPattern = [character(1) :: ]")

138 arrayPattern = [character(1) :: ]

139 call disp%show("index = getSIR(Array, arrayPattern)")

140 index = getSIR(Array, arrayPattern)

141 call disp%show("Array(:index)")

142 call disp%show( Array(:index), deliml = """" )

143 call disp%show("index")

144 call disp%show( index )

145 call disp%skip()

146

147 call disp%skip()

148 call disp%show("Array = ['bb', 'a ', 'a ']")

149 Array = ['bb', 'a ', 'a ']

150 call disp%show("arrayPattern = [character(1) :: ]")

151 arrayPattern = [character(1) :: ]

152 call disp%show("index = getSIR(Array, arrayPattern)")

153 index = getSIR(Array, arrayPattern)

154 call disp%show("Array(:index)")

155 call disp%show( Array(:index), deliml = """" )

156 call disp%show("index")

157 call disp%show( index )

158 call disp%skip()

159

160 call disp%skip()

161 call disp%show("Array = ['bb', 'a ', 'a ']")

162 Array = ['bb', 'a ', 'a ']

163 call disp%show("scalarPattern = 'a'")

164 scalarPattern = 'a'

165 call disp%show("index = getSIR(Array, scalarPattern)")

166 index = getSIR(Array, scalarPattern)

167 call disp%show("Array(:index)")

168 call disp%show( Array(:index), deliml = """" )

169 call disp%show("index")

170 call disp%show( index )

171 call disp%skip()

172

173 call disp%skip()

174 call disp%show("Array = ['bb', 'a ', 'a ']")

175 Array = ['bb', 'a ', 'a ']

176 call disp%show("arrayPattern = ['a', 'a']")

177 arrayPattern = ['a', 'a']

178 call disp%show("index = getSIR(Array, arrayPattern)")

179 index = getSIR(Array, arrayPattern)

180 call disp%show("Array(:index)")

181 call disp%show( Array(:index), deliml = """" )

182 call disp%show("index")

183 call disp%show( index )

184 call disp%skip()

185

186 call disp%skip()

187 call disp%show("Array = ['bb', 'a ', 'a ']")

188 Array = ['bb', 'a ', 'a ']

189 call disp%show("arrayPattern = 'bbb'")

190 arrayPattern = 'bbb'

191 call disp%show("index = getSIR(Array, arrayPattern)")

192 index = getSIR(Array, arrayPattern)

193 call disp%show("Array(:index)")

194 call disp%show( Array(:index), deliml = """" )

195 call disp%show("index")

196 call disp%show( index )

197 call disp%skip()

198

199 call disp%skip()

200 call disp%show("Array = ['bb', 'a ', 'a ']")

201 Array = ['bb', 'a ', 'a ']

202 call disp%show("arrayPattern = [Array, ' ']")

203 arrayPattern = [Array, ' ']

204 call disp%show("index = getSIR(Array, arrayPattern)")

205 index = getSIR(Array, arrayPattern)

206 call disp%show("Array(:index)")

207 call disp%show( Array(:index), deliml = """" )

208 call disp%show("index")

209 call disp%show( index )

210 call disp%skip()

211

212 call disp%skip()

213 call disp%show("Array = ['a ', 'A ', 'bb']")

214 Array = ['a ', 'A ', 'bb']

215 call disp%show("scalarPattern = 'A '")

216 scalarPattern = 'A '

217 call disp%show("index = getSIR(Array, scalarPattern)")

218 index = getSIR(Array, scalarPattern)

219 call disp%show("Array(:index)")

220 call disp%show( Array(:index), deliml = """" )

221 call disp%show("index")

222 call disp%show( index )

223 call disp%show("index = getSIR(Array, scalarPattern, iseqScalar_SK)")

224 index = getSIR(Array, scalarPattern, iseqScalar_SK)

225 call disp%show("Array(:index)")

226 call disp%show( Array(:index), deliml = """" )

227 call disp%show("index")

228 call disp%show( index )

229 call disp%skip()

230

231 call disp%skip()

232 call disp%show("Array = ['bb', 'a ', 'A ']")

233 Array = ['bb', 'a ', 'A ']

234 call disp%show("arrayPattern = ['A ', 'a ']")

235 arrayPattern = ['A ', 'a ']

236 call disp%show("index = getSIR(Array, arrayPattern)")

237 index = getSIR(Array, arrayPattern)

238 call disp%show("Array(:index)")

239 call disp%show( Array(:index), deliml = """" )

240 call disp%show("index")

241 call disp%show( index )

242 call disp%show("index = getSIR(Array, arrayPattern, iseqVector_SK)")

243 index = getSIR(Array, arrayPattern, iseqVector_SK)

244 call disp%show("Array(:index)")

245 call disp%show( Array(:index), deliml = """" )

246 call disp%show("index")

247 call disp%show( index )

248 call disp%skip()

249

250 end block

251

252 call disp%skip()

253 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

254 call disp%show("! Strip pattern from the beginning of a integer array.")

255 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

256 call disp%skip()

257

258 block

259 integer, allocatable :: Array(:)

260 integer, allocatable :: scalarPattern

261 integer, allocatable :: arrayPattern(:)

262

263 call disp%skip()

264 call disp%show("Array = [integer :: ]")

265 Array = [integer :: ]

266 call disp%show("arrayPattern = [integer :: ]")

267 arrayPattern = [integer :: ]

268 call disp%show("index = getSIR(Array, arrayPattern)")

269 index = getSIR(Array, arrayPattern)

270 call disp%show("Array(:index)")

271 call disp%show( Array(:index) )

272 call disp%show("index")

273 call disp%show( index )

274 call disp%skip()

275

276 call disp%skip()

277 call disp%show("Array = [2, 1, 1]")

278 Array = [2, 1, 1]

279 call disp%show("arrayPattern = [integer :: ]")

280 arrayPattern = [integer :: ]

281 call disp%show("index = getSIR(Array, arrayPattern)")

282 index = getSIR(Array, arrayPattern)

283 call disp%show("Array(:index)")

284 call disp%show( Array(:index) )

285 call disp%show("index")

286 call disp%show( index )

287 call disp%skip()

288

289 call disp%skip()

290 call disp%show("Array = [2, 1, 1]")

291 Array = [2, 1, 1]

292 call disp%show("scalarPattern = 1")

293 scalarPattern = 1

294 call disp%show("index = getSIR(Array, scalarPattern)")

295 index = getSIR(Array, scalarPattern)

296 call disp%show("Array(:index)")

297 call disp%show( Array(:index) )

298 call disp%show("index")

299 call disp%show( index )

300 call disp%skip()

301

302 call disp%skip()

303 call disp%show("Array = [2, 1, 1]")

304 Array = [2, 1, 1]

305 call disp%show("arrayPattern = [1, 1]")

306 arrayPattern = [1, 1]

307 call disp%show("index = getSIR(Array, arrayPattern)")

308 index = getSIR(Array, arrayPattern)

309 call disp%show("Array(:index)")

310 call disp%show( Array(:index) )

311 call disp%show("index")

312 call disp%show( index )

313 call disp%skip()

314

315 call disp%skip()

316 call disp%show("Array = [2, 1, 1]")

317 Array = [2, 1, 1]

318 call disp%show("arrayPattern = 3")

319 arrayPattern = 3

320 call disp%show("index = getSIR(Array, arrayPattern)")

321 index = getSIR(Array, arrayPattern)

322 call disp%show("Array(:index)")

323 call disp%show( Array(:index) )

324 call disp%show("index")

325 call disp%show( index )

326 call disp%skip()

327

328 call disp%skip()

329 call disp%show("Array = [2, 1, 1]")

330 Array = [2, 1, 1]

331 call disp%show("arrayPattern = Array")

332 arrayPattern = Array

333 call disp%show("index = getSIR(Array, arrayPattern)")

334 index = getSIR(Array, arrayPattern)

335 call disp%show("Array(:index)")

336 call disp%show( Array(:index) )

337 call disp%show("index")

338 call disp%show( index )

339 call disp%skip()

340

341 call disp%skip()

342 call disp%show("Array = [2, 1, 1]")

343 Array = [2, 1, 1]

344 call disp%show("arrayPattern = [Array, 0]")

345 arrayPattern = [Array, 0]

346 call disp%show("index = getSIR(Array, arrayPattern)")

347 index = getSIR(Array, arrayPattern)

348 call disp%show("Array(:index)")

349 call disp%show( Array(:index) )

350 call disp%show("index")

351 call disp%show( index )

352 call disp%skip()

353

354 call disp%skip()

355 call disp%show("Array = [2, -1, 1]")

356 Array = [2, -1, 1]

357 call disp%show("scalarPattern = 1")

358 scalarPattern = 1

359 call disp%show("index = getSIR(Array, scalarPattern)")

360 index = getSIR(Array, scalarPattern)

361 call disp%show("Array(:index)")

362 call disp%show( Array(:index) )

363 call disp%show("index")

364 call disp%show( index )

365 call disp%show("index = getSIR(Array, scalarPattern, iseqScalar_IK)")

366 index = getSIR(Array, scalarPattern, iseqScalar_IK)

367 call disp%show("Array(:index)")

368 call disp%show( Array(:index) )

369 call disp%show("index")

370 call disp%show( index )

371 call disp%skip()

372

373 call disp%skip()

374 call disp%show("Array = [2, -1, 1]")

375 Array = [2, -1, 1]

376 call disp%show("arrayPattern = [+1, -1]")

377 arrayPattern = [+1, -1]

378 call disp%show("index = getSIR(Array, arrayPattern)")

379 index = getSIR(Array, arrayPattern)

380 call disp%show("Array(:index)")

381 call disp%show( Array(:index) )

382 call disp%show("index")

383 call disp%show( index )

384 call disp%show("index = getSIR(Array, arrayPattern, iseqVector_IK)")

385 index = getSIR(Array, arrayPattern, iseqVector_IK)

386 call disp%show("Array(:index)")

387 call disp%show( Array(:index) )

388 call disp%show("index")

389 call disp%show( index )

390 call disp%skip()

391

392 end block

393

394 call disp%skip()

395 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

396 call disp%show("! Strip pattern from the beginning of a logical array.")

397 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

398 call disp%skip()

399

400 block

401 logical, allocatable :: Array(:)

402 logical, allocatable :: scalarPattern

403 logical, allocatable :: arrayPattern(:)

404

405 call disp%skip()

406 call disp%show("Array = [logical :: ]")

407 Array = [logical :: ]

408 call disp%show("arrayPattern = [logical :: ]")

409 arrayPattern = [logical :: ]

410 call disp%show("index = getSIR(Array, arrayPattern)")

411 index = getSIR(Array, arrayPattern)

412 call disp%show("Array(:index)")

413 call disp%show( Array(:index) )

414 call disp%show("index")

415 call disp%show( index )

416 call disp%skip()

417

418 call disp%skip()

419 call disp%show("Array = [.true., .false., .false.]")

420 Array = [.true., .false., .false.]

421 call disp%show("arrayPattern = [logical :: ]")

422 arrayPattern = [logical :: ]

423 call disp%show("index = getSIR(Array, arrayPattern)")

424 index = getSIR(Array, arrayPattern)

425 call disp%show("Array(:index)")

426 call disp%show( Array(:index) )

427 call disp%show("index")

428 call disp%show( index )

429 call disp%skip()

430

431 call disp%skip()

432 call disp%show("Array = [.true., .false., .false.]")

433 Array = [.true., .false., .false.]

434 call disp%show("scalarPattern = .false.")

435 scalarPattern = .false.

436 call disp%show("index = getSIR(Array, scalarPattern)")

437 index = getSIR(Array, scalarPattern)

438 call disp%show("Array(:index)")

439 call disp%show( Array(:index) )

440 call disp%show("index")

441 call disp%show( index )

442 call disp%skip()

443

444 call disp%skip()

445 call disp%show("Array = [.true., .false., .false.]")

446 Array = [.true., .false., .false.]

447 call disp%show("arrayPattern = [.false., .false.]")

448 arrayPattern = [.false., .false.]

449 call disp%show("index = getSIR(Array, arrayPattern)")

450 index = getSIR(Array, arrayPattern)

451 call disp%show("Array(:index)")

452 call disp%show( Array(:index) )

453 call disp%show("index")

454 call disp%show( index )

455 call disp%skip()

456

457 call disp%skip()

458 call disp%show("Array = [.true., .false., .false.]")

459 Array = [.true., .false., .false.]

460 call disp%show("arrayPattern = [.true., .true.]")

461 arrayPattern = [.true., .true.]

462 call disp%show("index = getSIR(Array, arrayPattern)")

463 index = getSIR(Array, arrayPattern)

464 call disp%show("Array(:index)")

465 call disp%show( Array(:index) )

466 call disp%show("index")

467 call disp%show( index )

468 call disp%skip()

469

470 call disp%skip()

471 call disp%show("Array = [.true., .false., .false.]")

472 Array = [.true., .false., .false.]

473 call disp%show("arrayPattern = Array")

474 arrayPattern = Array

475 call disp%show("index = getSIR(Array, arrayPattern)")

476 index = getSIR(Array, arrayPattern)

477 call disp%show("Array(:index)")

478 call disp%show( Array(:index) )

479 call disp%show("index")

480 call disp%show( index )

481 call disp%skip()

482

483 call disp%skip()

484 call disp%show("Array = [.true., .false., .false.]")

485 Array = [.true., .false., .false.]

486 call disp%show("arrayPattern = [Array, .false.]")

487 arrayPattern = [Array, .false.]

488 call disp%show("index = getSIR(Array, arrayPattern)")

489 index = getSIR(Array, arrayPattern)

490 call disp%show("Array(:index)")

491 call disp%show( Array(:index) )

492 call disp%show("index")

493 call disp%show( index )

494 call disp%skip()

495

496 call disp%skip()

497 call disp%show("Array = [.false., .true., .true.]")

498 Array = [.false., .true., .true.]

499 call disp%show("scalarPattern = .false.")

500 scalarPattern = .false.

501 call disp%show("index = getSIR(Array, scalarPattern)")

502 index = getSIR(Array, scalarPattern)

503 call disp%show("Array(:index)")

504 call disp%show( Array(:index) )

505 call disp%show("index")

506 call disp%show( index )

507 call disp%show("index = getSIR(Array, scalarPattern, iseqScalar_LK)")

508 index = getSIR(Array, scalarPattern, iseqScalar_LK)

509 call disp%show("Array(:index)")

510 call disp%show( Array(:index) )

511 call disp%show("index")

512 call disp%show( index )

513 call disp%skip()

514

515 call disp%skip()

516 call disp%show("Array = [.true., .true., .false.]")

517 Array = [.true., .true., .false.]

518 call disp%show("arrayPattern = [.false., .true.]")

519 arrayPattern = [.false., .true.]

520 call disp%show("index = getSIR(Array, arrayPattern)")

521 index = getSIR(Array, arrayPattern)

522 call disp%show("Array(:index)")

523 call disp%show( Array(:index) )

524 call disp%show("index")

525 call disp%show( index )

526 call disp%show("index = getSIR(Array, arrayPattern, iseqVector_LK)")

527 index = getSIR(Array, arrayPattern, iseqVector_LK)

528 call disp%show("Array(:index)")

529 call disp%show( Array(:index) )

530 call disp%show("index")

531 call disp%show( index )

532 call disp%skip()

533

534 end block

535

536 call disp%skip()

537 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

538 call disp%show("! Strip pattern from the beginning of a complex array.")

539 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

540 call disp%skip()

541

542 block

543 complex, allocatable :: Array(:)

544 complex, allocatable :: scalarPattern

545 complex, allocatable :: arrayPattern(:)

546

547 call disp%skip()

548 call disp%show("Array = [complex :: ]")

549 Array = [complex :: ]

550 call disp%show("arrayPattern = [complex :: ]")

551 arrayPattern = [complex :: ]

552 call disp%show("index = getSIR(Array, arrayPattern)")

553 index = getSIR(Array, arrayPattern)

554 call disp%show("Array(:index)")

555 call disp%show( Array(:index) )

556 call disp%show("index")

557 call disp%show( index )

558 call disp%skip()

559

560 call disp%skip()

561 call disp%show("Array = [2, 1, 1]")

562 Array = [2, 1, 1]

563 call disp%show("arrayPattern = [complex :: ]")

564 arrayPattern = [complex :: ]

565 call disp%show("index = getSIR(Array, arrayPattern)")

566 index = getSIR(Array, arrayPattern)

567 call disp%show("Array(:index)")

568 call disp%show( Array(:index) )

569 call disp%show("index")

570 call disp%show( index )

571 call disp%skip()

572

573 call disp%skip()

574 call disp%show("Array = [2, 1, 1]")

575 Array = [2, 1, 1]

576 call disp%show("scalarPattern = 1")

577 scalarPattern = 1

578 call disp%show("index = getSIR(Array, scalarPattern)")

579 index = getSIR(Array, scalarPattern)

580 call disp%show("Array(:index)")

581 call disp%show( Array(:index) )

582 call disp%show("index")

583 call disp%show( index )

584 call disp%skip()

585

586 call disp%skip()

587 call disp%show("Array = [2, 1, 1]")

588 Array = [2, 1, 1]

589 call disp%show("arrayPattern = [1, 1]")

590 arrayPattern = [1, 1]

591 call disp%show("index = getSIR(Array, arrayPattern)")

592 index = getSIR(Array, arrayPattern)

593 call disp%show("Array(:index)")

594 call disp%show( Array(:index) )

595 call disp%show("index")

596 call disp%show( index )

597 call disp%skip()

598

599 call disp%skip()

600 call disp%show("Array = [2, 1, 1]")

601 Array = [2, 1, 1]

602 call disp%show("arrayPattern = 3")

603 arrayPattern = 3

604 call disp%show("index = getSIR(Array, arrayPattern)")

605 index = getSIR(Array, arrayPattern)

606 call disp%show("Array(:index)")

607 call disp%show( Array(:index) )

608 call disp%show("index")

609 call disp%show( index )

610 call disp%skip()

611

612 call disp%skip()

613 call disp%show("Array = [2, 1, 1]")

614 Array = [2, 1, 1]

615 call disp%show("arrayPattern = Array")

616 arrayPattern = Array

617 call disp%show("index = getSIR(Array, arrayPattern)")

618 index = getSIR(Array, arrayPattern)

619 call disp%show("Array(:index)")

620 call disp%show( Array(:index) )

621 call disp%show("index")

622 call disp%show( index )

623 call disp%skip()

624

625 call disp%skip()

626 call disp%show("Array = [2, 1, 1]")

627 Array = [2, 1, 1]

628 call disp%show("arrayPattern = [Array, cmplx(0)]")

629 arrayPattern = [Array, cmplx(0)]

630 call disp%show("index = getSIR(Array, arrayPattern)")

631 index = getSIR(Array, arrayPattern)

632 call disp%show("Array(:index)")

633 call disp%show( Array(:index) )

634 call disp%show("index")

635 call disp%show( index )

636 call disp%skip()

637

638 call disp%skip()

639 call disp%show("Array = [2, -1, 1]")

640 Array = [2, -1, 1]

641 call disp%show("scalarPattern = 1")

642 scalarPattern = 1

643 call disp%show("index = getSIR(Array, scalarPattern)")

644 index = getSIR(Array, scalarPattern)

645 call disp%show("Array(:index)")

646 call disp%show( Array(:index) )

647 call disp%show("index")

648 call disp%show( index )

649 call disp%show("index = getSIR(Array, scalarPattern, iseqScalar_CK)")

650 index = getSIR(Array, scalarPattern, iseqScalar_CK)

651 call disp%show("Array(:index)")

652 call disp%show( Array(:index) )

653 call disp%show("index")

654 call disp%show( index )

655 call disp%skip()

656

657 call disp%skip()

658 call disp%show("Array = [2, -1, 1]")

659 Array = [2, -1, 1]

660 call disp%show("arrayPattern = [+1, -1]")

661 arrayPattern = [+1, -1]

662 call disp%show("index = getSIR(Array, arrayPattern)")

663 index = getSIR(Array, arrayPattern)

664 call disp%show("Array(:index)")

665 call disp%show( Array(:index) )

666 call disp%show("index")

667 call disp%show( index )

668 call disp%show("index = getSIR(Array, arrayPattern, iseqVector_CK)")

669 index = getSIR(Array, arrayPattern, iseqVector_CK)

670 call disp%show("Array(:index)")

671 call disp%show( Array(:index) )

672 call disp%show("index")

673 call disp%show( index )

674 call disp%skip()

675

676 end block

677

678 call disp%skip()

679 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

680 call disp%show("! Strip pattern from the beginning of a real array.")

681 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%")

682 call disp%skip()

683

684 block

685 real, allocatable :: Array(:)

686 real, allocatable :: scalarPattern

687 real, allocatable :: arrayPattern(:)

688

689 call disp%skip()

690 call disp%show("Array = [real :: ]")

691 Array = [real :: ]

692 call disp%show("arrayPattern = [real :: ]")

693 arrayPattern = [real :: ]

694 call disp%show("index = getSIR(Array, arrayPattern)")

695 index = getSIR(Array, arrayPattern)

696 call disp%show("Array(:index)")

697 call disp%show( Array(:index) )

698 call disp%show("index")

699 call disp%show( index )

700 call disp%skip()

701

702 call disp%skip()

703 call disp%show("Array = [2, 1, 1]")

704 Array = [2, 1, 1]

705 call disp%show("arrayPattern = [real :: ]")

706 arrayPattern = [real :: ]

707 call disp%show("index = getSIR(Array, arrayPattern)")

708 index = getSIR(Array, arrayPattern)

709 call disp%show("Array(:index)")

710 call disp%show( Array(:index) )

711 call disp%show("index")

712 call disp%show( index )

713 call disp%skip()

714

715 call disp%skip()

716 call disp%show("Array = [2, 1, 1]")

717 Array = [2, 1, 1]

718 call disp%show("scalarPattern = 1")

719 scalarPattern = 1

720 call disp%show("index = getSIR(Array, scalarPattern)")

721 index = getSIR(Array, scalarPattern)

722 call disp%show("Array(:index)")

723 call disp%show( Array(:index) )

724 call disp%show("index")

725 call disp%show( index )

726 call disp%skip()

727

728 call disp%skip()

729 call disp%show("Array = [2, 1, 1]")

730 Array = [2, 1, 1]

731 call disp%show("arrayPattern = [1, 1]")

732 arrayPattern = [1, 1]

733 call disp%show("index = getSIR(Array, arrayPattern)")

734 index = getSIR(Array, arrayPattern)

735 call disp%show("Array(:index)")

736 call disp%show( Array(:index) )

737 call disp%show("index")

738 call disp%show( index )

739 call disp%skip()

740

741 call disp%skip()

742 call disp%show("Array = [2, 1, 1]")

743 Array = [2, 1, 1]

744 call disp%show("arrayPattern = 3")

745 arrayPattern = 3

746 call disp%show("index = getSIR(Array, arrayPattern)")

747 index = getSIR(Array, arrayPattern)

748 call disp%show("Array(:index)")

749 call disp%show( Array(:index) )

750 call disp%show("index")

751 call disp%show( index )

752 call disp%skip()

753

754 call disp%skip()

755 call disp%show("Array = [2, 1, 1]")

756 Array = [2, 1, 1]

757 call disp%show("arrayPattern = Array")

758 arrayPattern = Array

759 call disp%show("index = getSIR(Array, arrayPattern)")

760 index = getSIR(Array, arrayPattern)

761 call disp%show("Array(:index)")

762 call disp%show( Array(:index) )

763 call disp%show("index")

764 call disp%show( index )

765 call disp%skip()

766

767 call disp%skip()

768 call disp%show("Array = [2, 1, 1]")

769 Array = [2, 1, 1]

770 call disp%show("arrayPattern = [Array, real(0)]")

771 arrayPattern = [Array, real(0)]

772 call disp%show("index = getSIR(Array, arrayPattern)")

773 index = getSIR(Array, arrayPattern)

774 call disp%show("Array(:index)")

775 call disp%show( Array(:index) )

776 call disp%show("index")

777 call disp%show( index )

778 call disp%skip()

779

780 call disp%skip()

781 call disp%show("Array = [2, -1, 1]")

782 Array = [2, -1, 1]

783 call disp%show("scalarPattern = 1")

784 scalarPattern = 1

785 call disp%show("index = getSIR(Array, scalarPattern)")

786 index = getSIR(Array, scalarPattern)

787 call disp%show("Array(:index)")

788 call disp%show( Array(:index) )

789 call disp%show("index")

790 call disp%show( index )

791 call disp%show("index = getSIR(Array, scalarPattern, iseqScalar_RK)")

792 index = getSIR(Array, scalarPattern, iseqScalar_RK)

793 call disp%show("Array(:index)")

794 call disp%show( Array(:index) )

795 call disp%show("index")

796 call disp%show( index )

797 call disp%skip()

798

799 call disp%skip()

800 call disp%show("Array = [2, -1, 1]")

801 Array = [2, -1, 1]

802 call disp%show("arrayPattern = [+1, -1]")

803 arrayPattern = [+1, -1]

804 call disp%show("index = getSIR(Array, arrayPattern)")

805 index = getSIR(Array, arrayPattern)

806 call disp%show("Array(:index)")

807 call disp%show( Array(:index) )

808 call disp%show("index")

809 call disp%show( index )

810 call disp%show("index = getSIR(Array, arrayPattern, iseqVector_RK)")

811 index = getSIR(Array, arrayPattern, iseqVector_RK)

812 call disp%show("Array(:index)")

813 call disp%show( Array(:index) )

814 call disp%show("index")

815 call disp%show( index )

816 call disp%skip()

817

818 end block

819

820contains

821

822 pure function iseqScalar_SK(segment, pattern) result(equivalent)

823 use pm_strASCII, only: getStrLower

824 character(*), intent(in) :: segment, pattern

825 logical(LK) :: equivalent

826 equivalent = getStrLower(segment) == getStrLower(pattern)

827 end

828

829 pure function iseqVector_SK(Segment, pattern, sizePattern) result(equivalent)

830 use pm_strASCII, only: getStrLower

831 integer(IK) , intent(in) :: sizePattern

832 character(*), intent(in) :: Segment(sizePattern), pattern(sizePattern)

833 logical(LK) :: equivalent

834 equivalent = all(getStrLower(Segment) == getStrLower(pattern))

835 end

836

837 pure function iseqScalar_IK(segment, pattern) result(equivalent)

838 integer , intent(in) :: segment, pattern

839 logical(LK) :: equivalent

840 equivalent = abs(segment) == abs(pattern)

841 end

842

843 pure function iseqVector_IK(Segment, pattern, sizePattern) result(equivalent)

844 integer(IK) , intent(in) :: sizePattern

845 integer , intent(in) :: Segment(sizePattern), pattern(sizePattern)

846 logical(LK) :: equivalent

847 equivalent = all(abs(Segment) == abs(pattern))

848 end

849

850 pure function iseqScalar_LK(segment, pattern) result(equivalent)

851 logical , intent(in) :: segment, pattern

852 logical(LK) :: equivalent

853 equivalent = segment .eqv. .not. pattern

854 end

855

856 pure function iseqVector_LK(Segment, pattern, sizePattern) result(equivalent)

857 integer(IK) , intent(in) :: sizePattern

858 logical , intent(in) :: Segment(sizePattern), pattern(sizePattern)

859 logical(LK) :: equivalent

860 equivalent = all(Segment .eqv. .not. pattern)

861 end

862

863 pure function iseqScalar_CK(segment, pattern) result(equivalent)

864 complex , intent(in) :: segment, pattern

865 logical(LK) :: equivalent

866 equivalent = abs(segment%re) == abs(pattern%re)

867 end

868

869 pure function iseqVector_CK(Segment, pattern, sizePattern) result(equivalent)

870 integer(IK) , intent(in) :: sizePattern

871 complex , intent(in) :: Segment(sizePattern), pattern(sizePattern)

872 logical(LK) :: equivalent

873 equivalent = all(abs(Segment%re) == abs(pattern%re))

874 end

875

876 pure function iseqScalar_RK(segment, pattern) result(equivalent)

877 real , intent(in) :: segment, pattern

878 logical(LK) :: equivalent

879 equivalent = abs(segment) == abs(pattern)

880 end

881

882 pure function iseqVector_RK(Segment, pattern, sizePattern) result(equivalent)

883 integer(IK) , intent(in) :: sizePattern

884 real , intent(in) :: Segment(sizePattern), pattern(sizePattern)

885 logical(LK) :: equivalent

886 equivalent = all(abs(Segment) == abs(pattern))

887 end

888

889end program example

pm_io::show
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11726

pm_io::skip
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11508

pm_strASCII::getStrLower
Generate and return the input string where the uppercase English alphabets are all converted to lower...
Definition: pm_strASCII.F90:4092

pm_io
This module contains classes and procedures for input/output (IO) or generic display operations on st...
Definition: pm_io.F90:252

pm_io::disp
type(display_type) disp
This is a scalar module variable an object of type display_type for general display.
Definition: pm_io.F90:11393

pm_strASCII
This module contains the uncommon and hardly representable ASCII characters as well as procedures for...
Definition: pm_strASCII.F90:61

pm_io::display_type
Generate and return an object of type display_type.
Definition: pm_io.F90:10282

Example Unix compile command via Intel ifort compiler ⛓
1#!/usr/bin/env sh

2rm main.exe

3ifort -fpp -standard-semantics -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe

4./main.exe

Example Windows Batch compile command via Intel ifort compiler ⛓
1del main.exe

2set PATH=..\..\..\lib;%PATH%

3ifort /fpp /standard-semantics /O3 /I:..\..\..\include main.F90 ..\..\..\lib\libparamonte*.lib /exe:main.exe

4main.exe

Example Unix / MinGW compile command via GNU gfortran compiler ⛓
1#!/usr/bin/env sh

2rm main.exe

3gfortran -cpp -ffree-line-length-none -O3 -Wl,-rpath,../../../lib -I../../../inc main.F90 ../../../lib/libparamonte* -o main.exe

4./main.exe

Example output ⛓
1

2!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

3! Strip pattern from the beginning of a string.

4!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

5

6

7string = ''

8pattern = ''

9index = getSIR(string, pattern)

10string(:index)

11""

12index

13+0

14

15

16string = 'bbaaa'

17pattern = ''

18index = getSIR(string, pattern)

19string(:index)

20"bbaaa"

21index

22+5

23

24

25string = 'bbaaa'

26pattern = 'a'

27index = getSIR(string, pattern)

28string(:index)

29"bb"

30index

31+2

32

33

34string = 'bbaaa'

35pattern = 'b'

36index = getSIR(string, pattern)

37string(:index)

38"bbaaa"

39index

40+5

41

42

43string = 'bbaaa'

44pattern = 'bbaaa '

45index = getSIR(string, pattern)

46string(:index)

47"bbaaa"

48index

49+5

50

51

52string = 'bbAa'

53pattern = 'aa'

54index = getSIR(string, pattern)

55string(:index)

56"bbAa"

57index

58+4

59index = getSIR(string, pattern, iseqScalar_SK)

60string(:index)

61"bb"

62index

63+2

64

65

66!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

67! Strip pattern from the beginning of a string array.

68!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

69

70

71Array = [character(2) :: ]

72scalarPattern = ''

73index = getSIR(Array, scalarPattern)

74Array(:index)

75

76index

77+0

78

79

80Array = [character(2) :: ]

81arrayPattern = [character(1) :: ]

82index = getSIR(Array, arrayPattern)

83Array(:index)

84

85index

86+0

87

88

89Array = ['bb', 'a ', 'a ']

90arrayPattern = [character(1) :: ]

91index = getSIR(Array, arrayPattern)

92Array(:index)

93"bb", "a ", "a "

94index

95+3

96

97

98Array = ['bb', 'a ', 'a ']

99scalarPattern = 'a'

100index = getSIR(Array, scalarPattern)

101Array(:index)

102"bb"

103index

104+1

105

106

107Array = ['bb', 'a ', 'a ']

108arrayPattern = ['a', 'a']

109index = getSIR(Array, arrayPattern)

110Array(:index)

111"bb"

112index

113+1

114

115

116Array = ['bb', 'a ', 'a ']

117arrayPattern = 'bbb'

118index = getSIR(Array, arrayPattern)

119Array(:index)

120"bb", "a ", "a "

121index

122+3

123

124

125Array = ['bb', 'a ', 'a ']

126arrayPattern = [Array, ' ']

127index = getSIR(Array, arrayPattern)

128Array(:index)

129"bb", "a ", "a "

130index

131+3

132

133

134Array = ['a ', 'A ', 'bb']

135scalarPattern = 'A '

136index = getSIR(Array, scalarPattern)

137Array(:index)

138"a ", "A ", "bb"

139index

140+3

141index = getSIR(Array, scalarPattern, iseqScalar_SK)

142Array(:index)

143"a ", "A ", "bb"

144index

145+3

146

147

148Array = ['bb', 'a ', 'A ']

149arrayPattern = ['A ', 'a ']

150index = getSIR(Array, arrayPattern)

151Array(:index)

152"bb", "a ", "A "

153index

154+3

155index = getSIR(Array, arrayPattern, iseqVector_SK)

156Array(:index)

157"bb"

158index

159+1

160

161

162!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

163! Strip pattern from the beginning of a integer array.

164!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

165

166

167Array = [integer :: ]

168arrayPattern = [integer :: ]

169index = getSIR(Array, arrayPattern)

170Array(:index)

171

172index

173+0

174

175

176Array = [2, 1, 1]

177arrayPattern = [integer :: ]

178index = getSIR(Array, arrayPattern)

179Array(:index)

180+2, +1, +1

181index

182+3

183

184

185Array = [2, 1, 1]

186scalarPattern = 1

187index = getSIR(Array, scalarPattern)

188Array(:index)

189+2

190index

191+1

192

193

194Array = [2, 1, 1]

195arrayPattern = [1, 1]

196index = getSIR(Array, arrayPattern)

197Array(:index)

198+2

199index

200+1

201

202

203Array = [2, 1, 1]

204arrayPattern = 3

205index = getSIR(Array, arrayPattern)

206Array(:index)

207+2, +1, +1

208index

209+3

210

211

212Array = [2, 1, 1]

213arrayPattern = Array

214index = getSIR(Array, arrayPattern)

215Array(:index)

216

217index

218+0

219

220

221Array = [2, 1, 1]

222arrayPattern = [Array, 0]

223index = getSIR(Array, arrayPattern)

224Array(:index)

225+2, +1, +1

226index

227+3

228

229

230Array = [2, -1, 1]

231scalarPattern = 1

232index = getSIR(Array, scalarPattern)

233Array(:index)

234+2, -1

235index

236+2

237index = getSIR(Array, scalarPattern, iseqScalar_IK)

238Array(:index)

239+2

240index

241+1

242

243

244Array = [2, -1, 1]

245arrayPattern = [+1, -1]

246index = getSIR(Array, arrayPattern)

247Array(:index)

248+2, -1, +1

249index

250+3

251index = getSIR(Array, arrayPattern, iseqVector_IK)

252Array(:index)

253+2

254index

255+1

256

257

258!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

259! Strip pattern from the beginning of a logical array.

260!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

261

262

263Array = [logical :: ]

264arrayPattern = [logical :: ]

265index = getSIR(Array, arrayPattern)

266Array(:index)

267

268index

269+0

270

271

272Array = [.true., .false., .false.]

273arrayPattern = [logical :: ]

274index = getSIR(Array, arrayPattern)

275Array(:index)

276T, F, F

277index

278+3

279

280

281Array = [.true., .false., .false.]

282scalarPattern = .false.

283index = getSIR(Array, scalarPattern)

284Array(:index)

285T

286index

287+1

288

289

290Array = [.true., .false., .false.]

291arrayPattern = [.false., .false.]

292index = getSIR(Array, arrayPattern)

293Array(:index)

294T

295index

296+1

297

298

299Array = [.true., .false., .false.]

300arrayPattern = [.true., .true.]

301index = getSIR(Array, arrayPattern)

302Array(:index)

303T, F, F

304index

305+3

306

307

308Array = [.true., .false., .false.]

309arrayPattern = Array

310index = getSIR(Array, arrayPattern)

311Array(:index)

312

313index

314+0

315

316

317Array = [.true., .false., .false.]

318arrayPattern = [Array, .false.]

319index = getSIR(Array, arrayPattern)

320Array(:index)

321T, F, F

322index

323+3

324

325

326Array = [.false., .true., .true.]

327scalarPattern = .false.

328index = getSIR(Array, scalarPattern)

329Array(:index)

330F, T, T

331index

332+3

333index = getSIR(Array, scalarPattern, iseqScalar_LK)

334Array(:index)

335F

336index

337+1

338

339

340Array = [.true., .true., .false.]

341arrayPattern = [.false., .true.]

342index = getSIR(Array, arrayPattern)

343Array(:index)

344T, T, F

345index

346+3

347index = getSIR(Array, arrayPattern, iseqVector_LK)

348Array(:index)

349T

350index

351+1

352

353

354!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

355! Strip pattern from the beginning of a complex array.

356!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

357

358

359Array = [complex :: ]

360arrayPattern = [complex :: ]

361index = getSIR(Array, arrayPattern)

362Array(:index)

363

364index

365+0

366

367

368Array = [2, 1, 1]

369arrayPattern = [complex :: ]

370index = getSIR(Array, arrayPattern)

371Array(:index)

372(+2.00000000, +0.00000000), (+1.00000000, +0.00000000), (+1.00000000, +0.00000000)

373index

374+3

375

376

377Array = [2, 1, 1]

378scalarPattern = 1

379index = getSIR(Array, scalarPattern)

380Array(:index)

381(+2.00000000, +0.00000000)

382index

383+1

384

385

386Array = [2, 1, 1]

387arrayPattern = [1, 1]

388index = getSIR(Array, arrayPattern)

389Array(:index)

390(+2.00000000, +0.00000000)

391index

392+1

393

394

395Array = [2, 1, 1]

396arrayPattern = 3

397index = getSIR(Array, arrayPattern)

398Array(:index)

399(+2.00000000, +0.00000000), (+1.00000000, +0.00000000), (+1.00000000, +0.00000000)

400index

401+3

402

403

404Array = [2, 1, 1]

405arrayPattern = Array

406index = getSIR(Array, arrayPattern)

407Array(:index)

408

409index

410+0

411

412

413Array = [2, 1, 1]

414arrayPattern = [Array, cmplx(0)]

415index = getSIR(Array, arrayPattern)

416Array(:index)

417(+2.00000000, +0.00000000), (+1.00000000, +0.00000000), (+1.00000000, +0.00000000)

418index

419+3

420

421

422Array = [2, -1, 1]

423scalarPattern = 1

424index = getSIR(Array, scalarPattern)

425Array(:index)

426(+2.00000000, +0.00000000), (-1.00000000, +0.00000000)

427index

428+2

429index = getSIR(Array, scalarPattern, iseqScalar_CK)

430Array(:index)

431(+2.00000000, +0.00000000)

432index

433+1

434

435

436Array = [2, -1, 1]

437arrayPattern = [+1, -1]

438index = getSIR(Array, arrayPattern)

439Array(:index)

440(+2.00000000, +0.00000000), (-1.00000000, +0.00000000), (+1.00000000, +0.00000000)

441index

442+3

443index = getSIR(Array, arrayPattern, iseqVector_CK)

444Array(:index)

445(+2.00000000, +0.00000000)

446index

447+1

448

449

450!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

451! Strip pattern from the beginning of a real array.

452!%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%

453

454

455Array = [real :: ]

456arrayPattern = [real :: ]

457index = getSIR(Array, arrayPattern)

458Array(:index)

459

460index

461+0

462

463

464Array = [2, 1, 1]

465arrayPattern = [real :: ]

466index = getSIR(Array, arrayPattern)

467Array(:index)

468+2.00000000, +1.00000000, +1.00000000

469index

470+3

471

472

473Array = [2, 1, 1]

474scalarPattern = 1

475index = getSIR(Array, scalarPattern)

476Array(:index)

477+2.00000000

478index

479+1

480

481

482Array = [2, 1, 1]

483arrayPattern = [1, 1]

484index = getSIR(Array, arrayPattern)

485Array(:index)

486+2.00000000

487index

488+1

489

490

491Array = [2, 1, 1]

492arrayPattern = 3

493index = getSIR(Array, arrayPattern)

494Array(:index)

495+2.00000000, +1.00000000, +1.00000000

496index

497+3

498

499

500Array = [2, 1, 1]

501arrayPattern = Array

502index = getSIR(Array, arrayPattern)

503Array(:index)

504

505index

506+0

507

508

509Array = [2, 1, 1]

510arrayPattern = [Array, real(0)]

511index = getSIR(Array, arrayPattern)

512Array(:index)

513+2.00000000, +1.00000000, +1.00000000

514index

515+3

516

517

518Array = [2, -1, 1]

519scalarPattern = 1

520index = getSIR(Array, scalarPattern)

521Array(:index)

522+2.00000000, -1.00000000

523index

524+2

525index = getSIR(Array, scalarPattern, iseqScalar_RK)

526Array(:index)

527+2.00000000

528index

529+1

530

531

532Array = [2, -1, 1]

533arrayPattern = [+1, -1]

534index = getSIR(Array, arrayPattern)

535Array(:index)

536+2.00000000, -1.00000000, +1.00000000

537index

538+3

539index = getSIR(Array, arrayPattern, iseqVector_RK)

540Array(:index)

541+2.00000000

542index

543+1

544

545

Test:: test_pm_arrayStrip

Final Remarks ⛓

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

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

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

Copyright: Computational Data Science Lab

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

Definition at line 6573 of file pm_arrayStrip.F90.

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

src/fortran/main/pm_arrayStrip.F90