Return the linSpace output argument with size(linSpace) elements of evenly-spaced values over the interval [x1, x2] if x1 < x2, or [x2, x1] if x2 < x1. More...

Detailed Description

Return the linSpace output argument with size(linSpace) elements of evenly-spaced values over the interval [x1, x2] if x1 < x2, or [x2, x1] if x2 < x1.

Parameters

[out]	linSpace	: The output `contiguous` array of either type `real` of kind any supported by the processor (e.g., RK, RK32, RK64, or RK128) or type `complex` of kind any supported by the processor (e.g., CK, CK32, CK64, or CK128) containing the evenly spaced numbers.
[in]	x1	: The input scalar of the same type and kind as `linSpace` representing the starting value of the sequence.
[in]	x2	: The input scalar of the same type and kind as `x1` representing the ending value of the sequence.
[in]	fopen	: The input scalar of type `logical` of default kind LK. If `.true.`, the `linSpace` will be first-open, meaning that `x1` will NOT be in the output `linSpace` sequence. (optional, default = `.false.`)
[in]	lopen	: The input scalar of type `logical` of default kind LK. If `.true.`, the `linSpace` will be last-open, meaning that `x2` will NOT be in the output `linSpace` sequence. (optional, default = `.false.`)

Possible calling interfaces ⛓

: use pm_arraySpace, only: setLinSpace

call setLinSpace(linSpace, x1, x2, fopen = fopen, lopen = lopen)

pm_arraySpace::setLinSpace
Return the linSpace output argument with size(linSpace) elements of evenly-spaced values over the int...
Definition: pm_arraySpace.F90:324

pm_arraySpace
This module contains procedures and generic interfaces for generating arrays with linear or logarithm...
Definition: pm_arraySpace.F90:33

Remarks: The procedures under discussion are pure.; Setting both fopen = .true. and lopen = .true. will lead to an output linSpace whose points are centers of the count + 1 equally-sized bins in the interval [x1,x2].; If linSpace has a size of 1 while fopen = .false. and lopen = .false., then linSpace = [x1] on return.

See also: getLinSpace
getLogSpace
setLogSpace

Example usage ⛓

: 1program example

2

3 use pm_kind, only: SK

4 use pm_io, only: display_type

5 use pm_kind, only: IK, LK, RKS, RKD, RKH, CKS, CKD, CKH

6 use pm_arraySpace, only: setLinSpace

7

8 implicit none

9

10 real(RKH) :: logSpace_RKH(4)

11 real(RKD) :: logSpace_RKD(4)

12 real(RKS) :: logSpace_RKS(4)

13 complex(CKH) :: logSpace_CKH(4)

14 complex(CKD) :: logSpace_CKD(4)

15 complex(CKS) :: logSpace_CKS(4)

16

17 type(display_type) :: disp

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

19

20 call disp%skip

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

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

23 call disp%show("!Generate real linspace.")

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

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

26 call disp%skip

27

28 call disp%skip

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

30 call disp%show("!32-bit real")

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

32 call disp%skip

33

34 call disp%skip

35 call disp%show("call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS)")

36 call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS)

37 call disp%show("logSpace_RKS")

38 call disp%show( logSpace_RKS )

39 call disp%skip

40 call disp%show("call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, fopen = .true._LK)")

41 call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, fopen = .true._LK)

42 call disp%show("logSpace_RKS")

43 call disp%show( logSpace_RKS )

44 call disp%skip

45 call disp%show("call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, lopen = .true._LK)")

46 call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, lopen = .true._LK)

47 call disp%show("logSpace_RKS")

48 call disp%show( logSpace_RKS )

49 call disp%skip

50 call disp%show("call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, fopen = .true._LK, lopen = .true._LK)")

51 call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, fopen = .true._LK, lopen = .true._LK)

52 call disp%show("logSpace_RKS")

53 call disp%show( logSpace_RKS )

54 call disp%skip

55

56 ! Generate sequence in reverse.

57

58 call disp%skip

59 call disp%show("call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS)")

60 call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS)

61 call disp%show("logSpace_RKS")

62 call disp%show( logSpace_RKS )

63 call disp%skip

64 call disp%show("call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, fopen = .true._LK)")

65 call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, fopen = .true._LK)

66 call disp%show("logSpace_RKS")

67 call disp%show( logSpace_RKS )

68 call disp%skip

69 call disp%show("call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, lopen = .true._LK)")

70 call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, lopen = .true._LK)

71 call disp%show("logSpace_RKS")

72 call disp%show( logSpace_RKS )

73 call disp%skip

74 call disp%show("call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, fopen = .true._LK, lopen = .true._LK)")

75 call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, fopen = .true._LK, lopen = .true._LK)

76 call disp%show("logSpace_RKS")

77 call disp%show( logSpace_RKS )

78 call disp%skip

79

80 call disp%skip

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

82 call disp%show("!64-bit real")

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

84 call disp%skip

85

86 call disp%skip

87 call disp%show("call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD)")

88 call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD)

89 call disp%show("logSpace_RKD")

90 call disp%show( logSpace_RKD )

91 call disp%skip

92 call disp%show("call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, fopen = .true._LK)")

93 call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, fopen = .true._LK)

94 call disp%show("logSpace_RKD")

95 call disp%show( logSpace_RKD )

96 call disp%skip

97 call disp%show("call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, lopen = .true._LK)")

98 call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, lopen = .true._LK)

99 call disp%show("logSpace_RKD")

100 call disp%show( logSpace_RKD )

101 call disp%skip

102 call disp%show("call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, fopen = .true._LK, lopen = .true._LK)")

103 call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, fopen = .true._LK, lopen = .true._LK)

104 call disp%show("logSpace_RKD")

105 call disp%show( logSpace_RKD )

106 call disp%skip

107

108 ! Generate sequence in reverse.

109

110 call disp%skip

111 call disp%show("call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD)")

112 call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD)

113 call disp%show("logSpace_RKD")

114 call disp%show( logSpace_RKD )

115 call disp%skip

116 call disp%show("call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, fopen = .true._LK)")

117 call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, fopen = .true._LK)

118 call disp%show("logSpace_RKD")

119 call disp%show( logSpace_RKD )

120 call disp%skip

121 call disp%show("call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, lopen = .true._LK)")

122 call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, lopen = .true._LK)

123 call disp%show("logSpace_RKD")

124 call disp%show( logSpace_RKD )

125 call disp%skip

126 call disp%show("call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, fopen = .true._LK, lopen = .true._LK)")

127 call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, fopen = .true._LK, lopen = .true._LK)

128 call disp%show("logSpace_RKD")

129 call disp%show( logSpace_RKD )

130 call disp%skip

131

132 call disp%skip

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

134 call disp%show("!128-bit real")

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

136 call disp%skip

137

138 call disp%skip

139 call disp%show("call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH)")

140 call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH)

141 call disp%show("logSpace_RKH")

142 call disp%show( logSpace_RKH )

143 call disp%skip

144 call disp%show("call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, fopen = .true._LK)")

145 call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, fopen = .true._LK)

146 call disp%show("logSpace_RKH")

147 call disp%show( logSpace_RKH )

148 call disp%skip

149 call disp%show("call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, lopen = .true._LK)")

150 call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, lopen = .true._LK)

151 call disp%show("logSpace_RKH")

152 call disp%show( logSpace_RKH )

153 call disp%skip

154 call disp%show("call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, fopen = .true._LK, lopen = .true._LK)")

155 call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, fopen = .true._LK, lopen = .true._LK)

156 call disp%show("logSpace_RKH")

157 call disp%show( logSpace_RKH )

158 call disp%skip

159

160 ! Generate sequence in reverse.

161

162 call disp%skip

163 call disp%show("call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH)")

164 call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH)

165 call disp%show("logSpace_RKH")

166 call disp%show( logSpace_RKH )

167 call disp%skip

168 call disp%show("call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, fopen = .true._LK)")

169 call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, fopen = .true._LK)

170 call disp%show("logSpace_RKH")

171 call disp%show( logSpace_RKH )

172 call disp%skip

173 call disp%show("call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, lopen = .true._LK)")

174 call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, lopen = .true._LK)

175 call disp%show("logSpace_RKH")

176 call disp%show( logSpace_RKH )

177 call disp%skip

178 call disp%show("call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, fopen = .true._LK, lopen = .true._LK)")

179 call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, fopen = .true._LK, lopen = .true._LK)

180 call disp%show("logSpace_RKH")

181 call disp%show( logSpace_RKH )

182 call disp%skip

183

184

185 call disp%skip

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

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

188 call disp%show("!Generate complex linspace.")

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

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

191 call disp%skip

192

193

194 call disp%skip

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

196 call disp%show("!32-bit complex")

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

198 call disp%skip

199

200 call disp%skip

201 call disp%show("call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS))")

202 call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS))

203 call disp%show("logSpace_CKS")

204 call disp%show( logSpace_CKS )

205 call disp%skip

206 call disp%show("call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), fopen = .true._LK)")

207 call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), fopen = .true._LK)

208 call disp%show("logSpace_CKS")

209 call disp%show( logSpace_CKS )

210 call disp%skip

211 call disp%show("call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), lopen = .true._LK)")

212 call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), lopen = .true._LK)

213 call disp%show("logSpace_CKS")

214 call disp%show( logSpace_CKS )

215 call disp%skip

216 call disp%show("call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), fopen = .true._LK, lopen = .true._LK)")

217 call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), fopen = .true._LK, lopen = .true._LK)

218 call disp%show("logSpace_CKS")

219 call disp%show( logSpace_CKS )

220 call disp%skip

221

222 ! Generate sequence in reverse.

223

224 call disp%skip

225 call disp%show("call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS))")

226 call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS))

227 call disp%show("logSpace_CKS")

228 call disp%show( logSpace_CKS )

229 call disp%skip

230 call disp%show("call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), fopen = .true._LK)")

231 call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), fopen = .true._LK)

232 call disp%show("logSpace_CKS")

233 call disp%show( logSpace_CKS )

234 call disp%skip

235 call disp%show("call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), lopen = .true._LK)")

236 call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), lopen = .true._LK)

237 call disp%show("logSpace_CKS")

238 call disp%show( logSpace_CKS )

239 call disp%skip

240 call disp%show("call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), fopen = .true._LK, lopen = .true._LK)")

241 call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), fopen = .true._LK, lopen = .true._LK)

242 call disp%show("logSpace_CKS")

243 call disp%show( logSpace_CKS )

244 call disp%skip

245

246 call disp%skip

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

248 call disp%show("!64-bit complex")

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

250 call disp%skip

251

252 call disp%skip

253 call disp%show("call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD))")

254 call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD))

255 call disp%show("logSpace_CKD")

256 call disp%show( logSpace_CKD )

257 call disp%skip

258 call disp%show("call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), fopen = .true._LK)")

259 call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), fopen = .true._LK)

260 call disp%show("logSpace_CKD")

261 call disp%show( logSpace_CKD )

262 call disp%skip

263 call disp%show("call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), lopen = .true._LK)")

264 call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), lopen = .true._LK)

265 call disp%show("logSpace_CKD")

266 call disp%show( logSpace_CKD )

267 call disp%skip

268 call disp%show("call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), fopen = .true._LK, lopen = .true._LK)")

269 call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), fopen = .true._LK, lopen = .true._LK)

270 call disp%show("logSpace_CKD")

271 call disp%show( logSpace_CKD )

272 call disp%skip

273

274 ! Generate sequence in reverse.

275

276 call disp%skip

277 call disp%show("call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD))")

278 call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD))

279 call disp%show("logSpace_CKD")

280 call disp%show( logSpace_CKD )

281 call disp%skip

282 call disp%show("call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), fopen = .true._LK)")

283 call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), fopen = .true._LK)

284 call disp%show("logSpace_CKD")

285 call disp%show( logSpace_CKD )

286 call disp%skip

287 call disp%show("call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), lopen = .true._LK)")

288 call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), lopen = .true._LK)

289 call disp%show("logSpace_CKD")

290 call disp%show( logSpace_CKD )

291 call disp%skip

292 call disp%show("call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), fopen = .true._LK, lopen = .true._LK)")

293 call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), fopen = .true._LK, lopen = .true._LK)

294 call disp%show("logSpace_CKD")

295 call disp%show( logSpace_CKD )

296 call disp%skip

297

298 call disp%skip

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

300 call disp%show("!128-bit complex")

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

302 call disp%skip

303

304 call disp%skip

305 call disp%show("call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH))")

306 call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH))

307 call disp%show("logSpace_CKH")

308 call disp%show( logSpace_CKH )

309 call disp%skip

310 call disp%show("call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), fopen = .true._LK)")

311 call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), fopen = .true._LK)

312 call disp%show("logSpace_CKH")

313 call disp%show( logSpace_CKH )

314 call disp%skip

315 call disp%show("call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), lopen = .true._LK)")

316 call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), lopen = .true._LK)

317 call disp%show("logSpace_CKH")

318 call disp%show( logSpace_CKH )

319 call disp%skip

320 call disp%show("call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), fopen = .true._LK, lopen = .true._LK)")

321 call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), fopen = .true._LK, lopen = .true._LK)

322 call disp%show("logSpace_CKH")

323 call disp%show( logSpace_CKH )

324 call disp%skip

325

326 ! Generate sequence in reverse.

327

328 call disp%skip

329 call disp%show("call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH))")

330 call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH))

331 call disp%show("logSpace_CKH")

332 call disp%show( logSpace_CKH )

333 call disp%skip

334 call disp%show("call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), fopen = .true._LK)")

335 call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), fopen = .true._LK)

336 call disp%show("logSpace_CKH")

337 call disp%show( logSpace_CKH )

338 call disp%skip

339 call disp%show("call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), lopen = .true._LK)")

340 call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), lopen = .true._LK)

341 call disp%show("logSpace_CKH")

342 call disp%show( logSpace_CKH )

343 call disp%skip

344 call disp%show("call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), fopen = .true._LK, lopen = .true._LK)")

345 call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), fopen = .true._LK, lopen = .true._LK)

346 call disp%show("logSpace_CKH")

347 call disp%show( logSpace_CKH )

348 call disp%skip

349

350end 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_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_kind
This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte librar...
Definition: pm_kind.F90:268

pm_kind::LK
integer, parameter LK
The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(....
Definition: pm_kind.F90:541

pm_kind::CKH
integer, parameter CKH
The scalar integer constant of intrinsic default kind, representing the highest-precision complex kin...
Definition: pm_kind.F90:843

pm_kind::CKS
integer, parameter CKS
The single-precision complex kind in Fortran mode. On most platforms, this is a 32-bit real kind.
Definition: pm_kind.F90:570

pm_kind::IK
integer, parameter IK
The default integer kind in the ParaMonte library: int32 in Fortran, c_int32_t in C-Fortran Interoper...
Definition: pm_kind.F90:540

pm_kind::CKD
integer, parameter CKD
The double precision complex kind in Fortran mode. On most platforms, this is a 64-bit real kind.
Definition: pm_kind.F90:571

pm_kind::RKD
integer, parameter RKD
The double precision real kind in Fortran mode. On most platforms, this is an 64-bit real kind.
Definition: pm_kind.F90:568

pm_kind::SK
integer, parameter SK
The default character kind in the ParaMonte library: kind("a") in Fortran, c_char in C-Fortran Intero...
Definition: pm_kind.F90:539

pm_kind::RKH
integer, parameter RKH
The scalar integer constant of intrinsic default kind, representing the highest-precision real kind t...
Definition: pm_kind.F90:858

pm_kind::RKS
integer, parameter RKS
The single-precision real kind in Fortran mode. On most platforms, this is an 32-bit real kind.
Definition: pm_kind.F90:567

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!%%%%%%%%%%%%%%%%%%%%%%%

4!Generate real linspace.

5!%%%%%%%%%%%%%%%%%%%%%%%

6!%%%%%%%%%%%%%%%%%%%%%%%

7

8

9!%%%%%%%%%%%

10!32-bit real

11!%%%%%%%%%%%

12

13

14call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS)

15logSpace_RKS

16+0.00000000, +3.33333325, +6.66666651, +10.0000000

17

18call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, fopen = .true._LK)

19logSpace_RKS

20+2.50000000, +5.00000000, +7.50000000, +10.0000000

21

22call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, lopen = .true._LK)

23logSpace_RKS

24+0.00000000, +2.50000000, +5.00000000, +7.50000000

25

26call setLinSpace(logSpace_RKS, 0._RKS, 10._RKS, fopen = .true._LK, lopen = .true._LK)

27logSpace_RKS

28+1.25000000, +3.75000000, +6.25000000, +8.75000000

29

30

31call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS)

32logSpace_RKS

33+10.0000000, +6.66666698, +3.33333349, +0.00000000

34

35call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, fopen = .true._LK)

36logSpace_RKS

37+7.50000000, +5.00000000, +2.50000000, +0.00000000

38

39call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, lopen = .true._LK)

40logSpace_RKS

41+10.0000000, +7.50000000, +5.00000000, +2.50000000

42

43call setLinSpace(logSpace_RKS, 10._RKS, 0._RKS, fopen = .true._LK, lopen = .true._LK)

44logSpace_RKS

45+8.75000000, +6.25000000, +3.75000000, +1.25000000

46

47

48!%%%%%%%%%%%

49!64-bit real

50!%%%%%%%%%%%

51

52

53call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD)

54logSpace_RKD

55+0.0000000000000000, +3.3333333333333335, +6.6666666666666670, +10.000000000000000

56

57call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, fopen = .true._LK)

58logSpace_RKD

59+2.5000000000000000, +5.0000000000000000, +7.5000000000000000, +10.000000000000000

60

61call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, lopen = .true._LK)

62logSpace_RKD

63+0.0000000000000000, +2.5000000000000000, +5.0000000000000000, +7.5000000000000000

64

65call setLinSpace(logSpace_RKD, 0._RKD, 10._RKD, fopen = .true._LK, lopen = .true._LK)

66logSpace_RKD

67+1.2500000000000000, +3.7500000000000000, +6.2500000000000000, +8.7500000000000000

68

69

70call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD)

71logSpace_RKD

72+10.000000000000000, +6.6666666666666661, +3.3333333333333330, +0.0000000000000000

73

74call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, fopen = .true._LK)

75logSpace_RKD

76+7.5000000000000000, +5.0000000000000000, +2.5000000000000000, +0.0000000000000000

77

78call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, lopen = .true._LK)

79logSpace_RKD

80+10.000000000000000, +7.5000000000000000, +5.0000000000000000, +2.5000000000000000

81

82call setLinSpace(logSpace_RKD, 10._RKD, 0._RKD, fopen = .true._LK, lopen = .true._LK)

83logSpace_RKD

84+8.7500000000000000, +6.2500000000000000, +3.7500000000000000, +1.2500000000000000

85

86

87!%%%%%%%%%%%%

88!128-bit real

89!%%%%%%%%%%%%

90

91

92call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH)

93logSpace_RKH

94+0.00000000000000000000000000000000000, +3.33333333333333333333333333333333346, +6.66666666666666666666666666666666692, +10.0000000000000000000000000000000000

95

96call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, fopen = .true._LK)

97logSpace_RKH

98+2.50000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.50000000000000000000000000000000000, +10.0000000000000000000000000000000000

99

100call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, lopen = .true._LK)

101logSpace_RKH

102+0.00000000000000000000000000000000000, +2.50000000000000000000000000000000000, +5.00000000000000000000000000000000000, +7.50000000000000000000000000000000000

103

104call setLinSpace(logSpace_RKH, 0._RKH, 10._RKH, fopen = .true._LK, lopen = .true._LK)

105logSpace_RKH

106+1.25000000000000000000000000000000000, +3.75000000000000000000000000000000000, +6.25000000000000000000000000000000000, +8.75000000000000000000000000000000000

107

108

109call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH)

110logSpace_RKH

111+10.0000000000000000000000000000000000, +6.66666666666666666666666666666666615, +3.33333333333333333333333333333333308, +0.00000000000000000000000000000000000

112

113call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, fopen = .true._LK)

114logSpace_RKH

115+7.50000000000000000000000000000000000, +5.00000000000000000000000000000000000, +2.50000000000000000000000000000000000, +0.00000000000000000000000000000000000

116

117call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, lopen = .true._LK)

118logSpace_RKH

119+10.0000000000000000000000000000000000, +7.50000000000000000000000000000000000, +5.00000000000000000000000000000000000, +2.50000000000000000000000000000000000

120

121call setLinSpace(logSpace_RKH, 10._RKH, 0._RKH, fopen = .true._LK, lopen = .true._LK)

122logSpace_RKH

123+8.75000000000000000000000000000000000, +6.25000000000000000000000000000000000, +3.75000000000000000000000000000000000, +1.25000000000000000000000000000000000

124

125

126!%%%%%%%%%%%%%%%%%%%%%%%%%%

127!%%%%%%%%%%%%%%%%%%%%%%%%%%

128!Generate complex linspace.

129!%%%%%%%%%%%%%%%%%%%%%%%%%%

130!%%%%%%%%%%%%%%%%%%%%%%%%%%

131

132

133!%%%%%%%%%%%%%%

134!32-bit complex

135!%%%%%%%%%%%%%%

136

137

138call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS))

139logSpace_CKS

140(+0.00000000, +0.00000000), (+3.33333325, +3.33333325), (+6.66666651, +6.66666651), (+10.0000000, +10.0000000)

141

142call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), fopen = .true._LK)

143logSpace_CKS

144(+2.50000000, +2.50000000), (+5.00000000, +5.00000000), (+7.50000000, +7.50000000), (+10.0000000, +10.0000000)

145

146call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), lopen = .true._LK)

147logSpace_CKS

148(+0.00000000, +0.00000000), (+2.50000000, +2.50000000), (+5.00000000, +5.00000000), (+7.50000000, +7.50000000)

149

150call setLinSpace(logSpace_CKS, (0._CKS,0._CKS), (10._CKS,10._CKS), fopen = .true._LK, lopen = .true._LK)

151logSpace_CKS

152(+1.25000000, +1.25000000), (+3.75000000, +3.75000000), (+6.25000000, +6.25000000), (+8.75000000, +8.75000000)

153

154

155call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS))

156logSpace_CKS

157(+10.0000000, -10.0000000), (+6.66666698, -6.66666698), (+3.33333349, -3.33333349), (+0.00000000, +0.00000000)

158

159call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), fopen = .true._LK)

160logSpace_CKS

161(+7.50000000, -7.50000000), (+5.00000000, -5.00000000), (+2.50000000, -2.50000000), (+0.00000000, +0.00000000)

162

163call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), lopen = .true._LK)

164logSpace_CKS

165(+10.0000000, -10.0000000), (+7.50000000, -7.50000000), (+5.00000000, -5.00000000), (+2.50000000, -2.50000000)

166

167call setLinSpace(logSpace_CKS, (10._CKS,-10._CKS), (0._CKS,0._CKS), fopen = .true._LK, lopen = .true._LK)

168logSpace_CKS

169(+8.75000000, -8.75000000), (+6.25000000, -6.25000000), (+3.75000000, -3.75000000), (+1.25000000, -1.25000000)

170

171

172!%%%%%%%%%%%%%%

173!64-bit complex

174!%%%%%%%%%%%%%%

175

176

177call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD))

178logSpace_CKD

179(+0.0000000000000000, +0.0000000000000000), (+3.3333333333333335, +3.3333333333333335), (+6.6666666666666670, +6.6666666666666670), (+10.000000000000000, +10.000000000000000)

180

181call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), fopen = .true._LK)

182logSpace_CKD

183(+2.5000000000000000, +2.5000000000000000), (+5.0000000000000000, +5.0000000000000000), (+7.5000000000000000, +7.5000000000000000), (+10.000000000000000, +10.000000000000000)

184

185call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), lopen = .true._LK)

186logSpace_CKD

187(+0.0000000000000000, +0.0000000000000000), (+2.5000000000000000, +2.5000000000000000), (+5.0000000000000000, +5.0000000000000000), (+7.5000000000000000, +7.5000000000000000)

188

189call setLinSpace(logSpace_CKD, (0._CKD,0._CKD), (10._CKD,10._CKD), fopen = .true._LK, lopen = .true._LK)

190logSpace_CKD

191(+1.2500000000000000, +1.2500000000000000), (+3.7500000000000000, +3.7500000000000000), (+6.2500000000000000, +6.2500000000000000), (+8.7500000000000000, +8.7500000000000000)

192

193

194call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD))

195logSpace_CKD

196(+10.000000000000000, -10.000000000000000), (+6.6666666666666661, -6.6666666666666661), (+3.3333333333333330, -3.3333333333333330), (+0.0000000000000000, +0.0000000000000000)

197

198call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), fopen = .true._LK)

199logSpace_CKD

200(+7.5000000000000000, -7.5000000000000000), (+5.0000000000000000, -5.0000000000000000), (+2.5000000000000000, -2.5000000000000000), (+0.0000000000000000, +0.0000000000000000)

201

202call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), lopen = .true._LK)

203logSpace_CKD

204(+10.000000000000000, -10.000000000000000), (+7.5000000000000000, -7.5000000000000000), (+5.0000000000000000, -5.0000000000000000), (+2.5000000000000000, -2.5000000000000000)

205

206call setLinSpace(logSpace_CKD, (10._CKD,-10._CKD), (0._CKD,0._CKD), fopen = .true._LK, lopen = .true._LK)

207logSpace_CKD

208(+8.7500000000000000, -8.7500000000000000), (+6.2500000000000000, -6.2500000000000000), (+3.7500000000000000, -3.7500000000000000), (+1.2500000000000000, -1.2500000000000000)

209

210

211!%%%%%%%%%%%%%%%

212!128-bit complex

213!%%%%%%%%%%%%%%%

214

215

216call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH))

217logSpace_CKH

218(+0.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (+3.33333333333333333333333333333333346, +3.33333333333333333333333333333333346), (+6.66666666666666666666666666666666692, +6.66666666666666666666666666666666692), (+10.0000000000000000000000000000000000, +10.0000000000000000000000000000000000)

219

220call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), fopen = .true._LK)

221logSpace_CKH

222(+2.50000000000000000000000000000000000, +2.50000000000000000000000000000000000), (+5.00000000000000000000000000000000000, +5.00000000000000000000000000000000000), (+7.50000000000000000000000000000000000, +7.50000000000000000000000000000000000), (+10.0000000000000000000000000000000000, +10.0000000000000000000000000000000000)

223

224call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), lopen = .true._LK)

225logSpace_CKH

226(+0.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (+2.50000000000000000000000000000000000, +2.50000000000000000000000000000000000), (+5.00000000000000000000000000000000000, +5.00000000000000000000000000000000000), (+7.50000000000000000000000000000000000, +7.50000000000000000000000000000000000)

227

228call setLinSpace(logSpace_CKH, (0._CKH,0._CKH), (10._CKH,10._CKH), fopen = .true._LK, lopen = .true._LK)

229logSpace_CKH

230(+1.25000000000000000000000000000000000, +1.25000000000000000000000000000000000), (+3.75000000000000000000000000000000000, +3.75000000000000000000000000000000000), (+6.25000000000000000000000000000000000, +6.25000000000000000000000000000000000), (+8.75000000000000000000000000000000000, +8.75000000000000000000000000000000000)

231

232

233call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH))

234logSpace_CKH

235(+10.0000000000000000000000000000000000, -10.0000000000000000000000000000000000), (+6.66666666666666666666666666666666615, -6.66666666666666666666666666666666615), (+3.33333333333333333333333333333333308, -3.33333333333333333333333333333333308), (+0.00000000000000000000000000000000000, +0.00000000000000000000000000000000000)

236

237call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), fopen = .true._LK)

238logSpace_CKH

239(+7.50000000000000000000000000000000000, -7.50000000000000000000000000000000000), (+5.00000000000000000000000000000000000, -5.00000000000000000000000000000000000), (+2.50000000000000000000000000000000000, -2.50000000000000000000000000000000000), (+0.00000000000000000000000000000000000, +0.00000000000000000000000000000000000)

240

241call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), lopen = .true._LK)

242logSpace_CKH

243(+10.0000000000000000000000000000000000, -10.0000000000000000000000000000000000), (+7.50000000000000000000000000000000000, -7.50000000000000000000000000000000000), (+5.00000000000000000000000000000000000, -5.00000000000000000000000000000000000), (+2.50000000000000000000000000000000000, -2.50000000000000000000000000000000000)

244

245call setLinSpace(logSpace_CKH, (10._CKH,-10._CKH), (0._CKH,0._CKH), fopen = .true._LK, lopen = .true._LK)

246logSpace_CKH

247(+8.75000000000000000000000000000000000, -8.75000000000000000000000000000000000), (+6.25000000000000000000000000000000000, -6.25000000000000000000000000000000000), (+3.75000000000000000000000000000000000, -3.75000000000000000000000000000000000), (+1.25000000000000000000000000000000000, -1.25000000000000000000000000000000000)

248

249

Test:: test_pm_arraySpace

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:: Fatemeh Bagheri, Tuesday 08:49 PM, August 10, 2021, Dallas, TX

Definition at line 324 of file pm_arraySpace.F90.

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

src/fortran/main/pm_arraySpace.F90