ParaMonte Fortran 2.0.0
Parallel Monte Carlo and Machine Learning Library
See the latest version documentation.
pm_arraySpace::setLogSpace Interface Reference

Return the logSpace output argument with size(logSpace) elements of logarithmically-evenly-spaced values over the interval [base**logx1, base**logx2] if logx1 < logx2, or over the interval [logx2, logx1] if logx2 < logx1. More...

Detailed Description

Return the logSpace output argument with size(logSpace) elements of logarithmically-evenly-spaced values over the interval [base**logx1, base**logx2] if logx1 < logx2, or over the interval [logx2, logx1] if logx2 < logx1.

Parameters
[out]logSpace: The output contiguous array of shape (:) of type either real of kind any supported by the processor (e.g., RK, RK32, RK64, or RK128) or complex of kind any supported by the processor (e.g., CK, CK32, CK64, or CK128) containing the log-evenly-spaced sequence within the interval specified by logx1 and logx2.
[in]logx1: The input scalar of the same type and kind as logSpace representing the starting exponent such that base**logx1 is the starting value of the sequence.
[in]logx2: The input scalar of the same type and kind as logSpace representing the ending exponent such that base**logx1 is the last value of the sequence.
[in]fopen: The input scalar of type logical of default kind LK. If .true., the logSpace will be first-open, meaning that logx1 will NOT be in the output logSpace sequence
(optional, default = .false.)
[in]lopen: The input scalar of type logical of default kind LK. If .true., the logSpace will be last-open, meaning that logx2 will NOT be in the output logSpace sequence
(optional, default = .false.)
[in]base: The input scalar of type real but the same kind as logSpace representing the base of the logarithm
(optional, default = exp(1), that is, Euler`s number).


Possible calling interfaces

call setLogSpace(logSpace, logx1, logx2, fopen = fopen, lopen = lopen, base = base)
Return the logSpace output argument with size(logSpace) elements of logarithmically-evenly-spaced val...
This module contains procedures and generic interfaces for generating arrays with linear or logarithm...
Remarks
The procedures under discussion are pure.
Setting both fopen = .true. and lopen = .true. will lead to an output logSpace whose points are centers of the count equally-sized bins in the interval [logx1,logx2].
See also
getLogSpace
getLinSpace
setLinSpace


Example usage

1program example
2
3 use pm_kind, only: LK, SK
4 use pm_io, only: display_type
5 use pm_kind, only: IK, RKS, RKD, RKH, CKS, CKD, CKH
6 use pm_arraySpace, only: setLogSpace
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 logspace.")
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%show("call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS)")
35 call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS)
36 call disp%show("logSpace_RKS")
37 call disp%show( logSpace_RKS )
38 call disp%show("call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, base = 10._RKS)")
39 call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, base = 10._RKS)
40 call disp%show("logSpace_RKS")
41 call disp%show( logSpace_RKS )
42 call disp%show("call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, fopen = .true._LK, base = 10._RKS)")
43 call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, fopen = .true._LK, base = 10._RKS)
44 call disp%show("logSpace_RKS")
45 call disp%show( logSpace_RKS )
46 call disp%show("call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, lopen = .true._LK, base = 10._RKS)")
47 call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, lopen = .true._LK, base = 10._RKS)
48 call disp%show("logSpace_RKS")
49 call disp%show( logSpace_RKS )
50 call disp%show("call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, fopen = .true._LK, lopen = .true._LK, base = 10._RKS)")
51 call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, fopen = .true._LK, lopen = .true._LK, base = 10._RKS)
52 call disp%show("logSpace_RKS")
53 call disp%show( logSpace_RKS )
54
55 ! Generate sequence in reverse.
56
57 call disp%show("call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS)")
58 call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS)
59 call disp%show("logSpace_RKS")
60 call disp%show( logSpace_RKS )
61 call disp%show("call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, base = 10._RKS)")
62 call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, base = 10._RKS)
63 call disp%show("logSpace_RKS")
64 call disp%show( logSpace_RKS )
65 call disp%show("call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, fopen = .true._LK, base = 10._RKS)")
66 call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, fopen = .true._LK, base = 10._RKS)
67 call disp%show("logSpace_RKS")
68 call disp%show( logSpace_RKS )
69 call disp%show("call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, lopen = .true._LK, base = 10._RKS)")
70 call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, lopen = .true._LK, base = 10._RKS)
71 call disp%show("logSpace_RKS")
72 call disp%show( logSpace_RKS )
73 call disp%show("call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, fopen = .true._LK, lopen = .true._LK, base = 10._RKS)")
74 call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, fopen = .true._LK, lopen = .true._LK, base = 10._RKS)
75 call disp%show("logSpace_RKS")
76 call disp%show( logSpace_RKS )
77
78 call disp%skip()
79 call disp%show("!%%%%%%%%%%")
80 call disp%show("64-bit real")
81 call disp%show("!%%%%%%%%%%")
82 call disp%skip()
83
84 call disp%show("call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD)")
85 call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD)
86 call disp%show("logSpace_RKD")
87 call disp%show( logSpace_RKD )
88 call disp%show("call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, base = 10._RKD)")
89 call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, base = 10._RKD)
90 call disp%show("logSpace_RKD")
91 call disp%show( logSpace_RKD )
92 call disp%show("call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, fopen = .true._LK, base = 10._RKD)")
93 call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, fopen = .true._LK, base = 10._RKD)
94 call disp%show("logSpace_RKD")
95 call disp%show( logSpace_RKD )
96 call disp%show("call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, lopen = .true._LK, base = 10._RKD)")
97 call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, lopen = .true._LK, base = 10._RKD)
98 call disp%show("logSpace_RKD")
99 call disp%show( logSpace_RKD )
100 call disp%show("call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, fopen = .true._LK, lopen = .true._LK, base = 10._RKD)")
101 call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, fopen = .true._LK, lopen = .true._LK, base = 10._RKD)
102 call disp%show("logSpace_RKD")
103 call disp%show( logSpace_RKD )
104
105 ! Generate sequence in reverse.
106
107 call disp%show("call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD)")
108 call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD)
109 call disp%show("logSpace_RKD")
110 call disp%show( logSpace_RKD )
111 call disp%show("call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, base = 10._RKD)")
112 call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, base = 10._RKD)
113 call disp%show("logSpace_RKD")
114 call disp%show( logSpace_RKD )
115 call disp%show("call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, fopen = .true._LK, base = 10._RKD)")
116 call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, fopen = .true._LK, base = 10._RKD)
117 call disp%show("logSpace_RKD")
118 call disp%show( logSpace_RKD )
119 call disp%show("call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, lopen = .true._LK, base = 10._RKD)")
120 call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, lopen = .true._LK, base = 10._RKD)
121 call disp%show("logSpace_RKD")
122 call disp%show( logSpace_RKD )
123 call disp%show("call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, fopen = .true._LK, lopen = .true._LK, base = 10._RKD)")
124 call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, fopen = .true._LK, lopen = .true._LK, base = 10._RKD)
125 call disp%show("logSpace_RKD")
126 call disp%show( logSpace_RKD )
127
128 call disp%skip()
129 call disp%show("!%%%%%%%%%%%")
130 call disp%show("128-bit real")
131 call disp%show("!%%%%%%%%%%%")
132 call disp%skip()
133
134 call disp%show("call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH)")
135 call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH)
136 call disp%show("logSpace_RKH")
137 call disp%show( logSpace_RKH )
138 call disp%show("call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, base = 10._RKH)")
139 call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, base = 10._RKH)
140 call disp%show("logSpace_RKH")
141 call disp%show( logSpace_RKH )
142 call disp%show("call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, fopen = .true._LK, base = 10._RKH)")
143 call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, fopen = .true._LK, base = 10._RKH)
144 call disp%show("logSpace_RKH")
145 call disp%show( logSpace_RKH )
146 call disp%show("call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, lopen = .true._LK, base = 10._RKH)")
147 call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, lopen = .true._LK, base = 10._RKH)
148 call disp%show("logSpace_RKH")
149 call disp%show( logSpace_RKH )
150 call disp%show("call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, fopen = .true._LK, lopen = .true._LK, base = 10._RKH)")
151 call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, fopen = .true._LK, lopen = .true._LK, base = 10._RKH)
152 call disp%show("logSpace_RKH")
153 call disp%show( logSpace_RKH )
154
155 ! Generate sequence in reverse.
156
157 call disp%show("call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH)")
158 call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH)
159 call disp%show("logSpace_RKH")
160 call disp%show( logSpace_RKH )
161 call disp%show("call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, base = 10._RKH)")
162 call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, base = 10._RKH)
163 call disp%show("logSpace_RKH")
164 call disp%show( logSpace_RKH )
165 call disp%show("call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, fopen = .true._LK, base = 10._RKH)")
166 call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, fopen = .true._LK, base = 10._RKH)
167 call disp%show("logSpace_RKH")
168 call disp%show( logSpace_RKH )
169 call disp%show("call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, lopen = .true._LK, base = 10._RKH)")
170 call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, lopen = .true._LK, base = 10._RKH)
171 call disp%show("logSpace_RKH")
172 call disp%show( logSpace_RKH )
173 call disp%show("call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, fopen = .true._LK, lopen = .true._LK, base = 10._RKH)")
174 call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, fopen = .true._LK, lopen = .true._LK, base = 10._RKH)
175 call disp%show("logSpace_RKH")
176 call disp%show( logSpace_RKH )
177
178
179 call disp%skip()
180 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%")
181 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%")
182 call disp%show("Generate complex logspace.")
183 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%")
184 call disp%show("!%%%%%%%%%%%%%%%%%%%%%%%%%")
185 call disp%skip()
186
187
188 call disp%skip()
189 call disp%show("!%%%%%%%%%%%%%")
190 call disp%show("32-bit complex")
191 call disp%show("!%%%%%%%%%%%%%")
192 call disp%skip()
193
194 call disp%show("call setLogSpace(logSpace_CKS, (1._CKS,1._CKS), (4._CKS,4._CKS))")
195 call setLogSpace(logSpace_CKS, (1._CKS,1._CKS), (4._CKS,4._CKS))
196 call disp%show("logSpace_CKS")
197 call disp%show( logSpace_CKS )
198 call disp%show("call setLogSpace(logSpace_CKS, (1._CKS,1._CKS), (4._CKS,4._CKS), base = 10._CKS)")
199 call setLogSpace(logSpace_CKS, (1._CKS,1._CKS), (4._CKS,4._CKS), base = 10._CKS)
200 call disp%show("logSpace_CKS")
201 call disp%show( logSpace_CKS )
202 call disp%show("call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), fopen = .true._LK, base = 10._CKS)")
203 call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), fopen = .true._LK, base = 10._CKS)
204 call disp%show("logSpace_CKS")
205 call disp%show( logSpace_CKS )
206 call disp%show("call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), lopen = .true._LK, base = 10._CKS)")
207 call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), lopen = .true._LK, base = 10._CKS)
208 call disp%show("logSpace_CKS")
209 call disp%show( logSpace_CKS )
210 call disp%show("call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), fopen = .true._LK, lopen = .true._LK, base = 10._CKS)")
211 call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), fopen = .true._LK, lopen = .true._LK, base = 10._CKS)
212 call disp%show("logSpace_CKS")
213 call disp%show( logSpace_CKS )
214
215 ! Generate sequence in reverse.
216
217 call disp%show("call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS))")
218 call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS))
219 call disp%show("logSpace_CKS")
220 call disp%show( logSpace_CKS )
221 call disp%show("call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), base = 10._CKS)")
222 call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), base = 10._CKS)
223 call disp%show("logSpace_CKS")
224 call disp%show( logSpace_CKS )
225 call disp%show("call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), fopen = .true._LK, base = 10._CKS)")
226 call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), fopen = .true._LK, base = 10._CKS)
227 call disp%show("logSpace_CKS")
228 call disp%show( logSpace_CKS )
229 call disp%show("call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), lopen = .true._LK, base = 10._CKS)")
230 call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), lopen = .true._LK, base = 10._CKS)
231 call disp%show("logSpace_CKS")
232 call disp%show( logSpace_CKS )
233 call disp%show("call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), fopen = .true._LK, lopen = .true._LK, base = 10._CKS)")
234 call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), fopen = .true._LK, lopen = .true._LK, base = 10._CKS)
235 call disp%show("logSpace_CKS")
236 call disp%show( logSpace_CKS )
237
238 call disp%skip()
239 call disp%show("!%%%%%%%%%%%%%")
240 call disp%show("64-bit complex")
241 call disp%show("!%%%%%%%%%%%%%")
242 call disp%skip()
243
244 call disp%show("call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD))")
245 call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD))
246 call disp%show("logSpace_CKD")
247 call disp%show( logSpace_CKD )
248 call disp%show("call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), base = 10._CKD)")
249 call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), base = 10._CKD)
250 call disp%show("logSpace_CKD")
251 call disp%show( logSpace_CKD )
252 call disp%show("call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), fopen = .true._LK, base = 10._CKD)")
253 call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), fopen = .true._LK, base = 10._CKD)
254 call disp%show("logSpace_CKD")
255 call disp%show( logSpace_CKD )
256 call disp%show("call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), lopen = .true._LK, base = 10._CKD)")
257 call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), lopen = .true._LK, base = 10._CKD)
258 call disp%show("logSpace_CKD")
259 call disp%show( logSpace_CKD )
260 call disp%show("call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), fopen = .true._LK, lopen = .true._LK, base = 10._CKD)")
261 call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), fopen = .true._LK, lopen = .true._LK, base = 10._CKD)
262 call disp%show("logSpace_CKD")
263 call disp%show( logSpace_CKD )
264
265 ! Generate sequence in reverse.
266
267 call disp%show("call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD))")
268 call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD))
269 call disp%show("logSpace_CKD")
270 call disp%show( logSpace_CKD )
271 call disp%show("call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), base = 10._CKD)")
272 call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), base = 10._CKD)
273 call disp%show("logSpace_CKD")
274 call disp%show( logSpace_CKD )
275 call disp%show("call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), fopen = .true._LK, base = 10._CKD)")
276 call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), fopen = .true._LK, base = 10._CKD)
277 call disp%show("logSpace_CKD")
278 call disp%show( logSpace_CKD )
279 call disp%show("call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), lopen = .true._LK, base = 10._CKD)")
280 call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), lopen = .true._LK, base = 10._CKD)
281 call disp%show("logSpace_CKD")
282 call disp%show( logSpace_CKD )
283 call disp%show("call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), fopen = .true._LK, lopen = .true._LK, base = 10._CKD)")
284 call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), fopen = .true._LK, lopen = .true._LK, base = 10._CKD)
285 call disp%show("logSpace_CKD")
286 call disp%show( logSpace_CKD )
287
288 call disp%skip()
289 call disp%show("!%%%%%%%%%%%%%%")
290 call disp%show("128-bit complex")
291 call disp%show("!%%%%%%%%%%%%%%")
292 call disp%skip()
293
294 call disp%show("call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH))")
295 call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH))
296 call disp%show("logSpace_CKH")
297 call disp%show( logSpace_CKH )
298 call disp%show("call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), base = 10._CKH)")
299 call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), base = 10._CKH)
300 call disp%show("logSpace_CKH")
301 call disp%show( logSpace_CKH )
302 call disp%show("call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), fopen = .true._LK, base = 10._CKH)")
303 call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), fopen = .true._LK, base = 10._CKH)
304 call disp%show("logSpace_CKH")
305 call disp%show( logSpace_CKH )
306 call disp%show("call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), lopen = .true._LK, base = 10._CKH)")
307 call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), lopen = .true._LK, base = 10._CKH)
308 call disp%show("logSpace_CKH")
309 call disp%show( logSpace_CKH )
310 call disp%show("call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), fopen = .true._LK, lopen = .true._LK, base = 10._CKH)")
311 call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), fopen = .true._LK, lopen = .true._LK, base = 10._CKH)
312 call disp%show("logSpace_CKH")
313 call disp%show( logSpace_CKH )
314
315 ! Generate sequence in reverse.
316
317 call disp%show("call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH))")
318 call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH))
319 call disp%show("logSpace_CKH")
320 call disp%show( logSpace_CKH )
321 call disp%show("call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), base = 10._CKH)")
322 call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), base = 10._CKH)
323 call disp%show("logSpace_CKH")
324 call disp%show( logSpace_CKH )
325 call disp%show("call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), fopen = .true._LK, base = 10._CKH)")
326 call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), fopen = .true._LK, base = 10._CKH)
327 call disp%show("logSpace_CKH")
328 call disp%show( logSpace_CKH )
329 call disp%show("call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), lopen = .true._LK, base = 10._CKH)")
330 call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), lopen = .true._LK, base = 10._CKH)
331 call disp%show("logSpace_CKH")
332 call disp%show( logSpace_CKH )
333 call disp%show("call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), fopen = .true._LK, lopen = .true._LK, base = 10._CKH)")
334 call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), fopen = .true._LK, lopen = .true._LK, base = 10._CKH)
335 call disp%show("logSpace_CKH")
336 call disp%show( logSpace_CKH )
337
338end program example
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11726
This is a generic method of the derived type display_type with pass attribute.
Definition: pm_io.F90:11508
This module contains classes and procedures for input/output (IO) or generic display operations on st...
Definition: pm_io.F90:252
type(display_type) disp
This is a scalar module variable an object of type display_type for general display.
Definition: pm_io.F90:11393
This module defines the relevant Fortran kind type-parameters frequently used in the ParaMonte librar...
Definition: pm_kind.F90:268
integer, parameter LK
The default logical kind in the ParaMonte library: kind(.true.) in Fortran, kind(....
Definition: pm_kind.F90:541
integer, parameter CKH
The scalar integer constant of intrinsic default kind, representing the highest-precision complex kin...
Definition: pm_kind.F90:843
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
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
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
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
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
integer, parameter RKH
The scalar integer constant of intrinsic default kind, representing the highest-precision real kind t...
Definition: pm_kind.F90:858
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
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!%%%%%%%%%%%%%%%%%%%%%%
4Generate real logspace.
5!%%%%%%%%%%%%%%%%%%%%%%
6!%%%%%%%%%%%%%%%%%%%%%%
7
8
9!%%%%%%%%%%
1032-bit real
11!%%%%%%%%%%
12
13call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS)
14logSpace_RKS
15+1.00000000, +3.79366803, +14.3919163, +54.5981445
16call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, base = 10._RKS)
17logSpace_RKS
18+1.00000000, +21.5443497, +464.158966, +10000.0000
19call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, fopen = .true._LK, base = 10._RKS)
20logSpace_RKS
21+10.0000000, +100.000000, +1000.00000, +10000.0000
22call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, lopen = .true._LK, base = 10._RKS)
23logSpace_RKS
24+1.00000000, +10.0000000, +100.000000, +1000.00000
25call setLogSpace(logSpace_RKS, 0._RKS, 4._RKS, fopen = .true._LK, lopen = .true._LK, base = 10._RKS)
26logSpace_RKS
27+3.16227770, +31.6227760, +316.227753, +3162.27759
28call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS)
29logSpace_RKS
30+54.5981445, +14.3919134, +3.79366755, +1.00000000
31call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, base = 10._RKS)
32logSpace_RKS
33+10000.0000, +464.158722, +21.5443420, +1.00000000
34call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, fopen = .true._LK, base = 10._RKS)
35logSpace_RKS
36+1000.00000, +100.000000, +10.0000000, +1.00000000
37call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, lopen = .true._LK, base = 10._RKS)
38logSpace_RKS
39+10000.0000, +1000.00000, +100.000000, +10.0000000
40call setLogSpace(logSpace_RKS, 4._RKS, 0._RKS, fopen = .true._LK, lopen = .true._LK, base = 10._RKS)
41logSpace_RKS
42+3162.27759, +316.227753, +31.6227760, +3.16227770
43
44!%%%%%%%%%%
4564-bit real
46!%%%%%%%%%%
47
48call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD)
49logSpace_RKD
50+1.0000000000000000, +3.7936678946831779, +14.391916095149890, +54.598150033144243
51call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, base = 10._RKD)
52logSpace_RKD
53+1.0000000000000000, +21.544346900318832, +464.15888336127773, +10000.000000000000
54call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, fopen = .true._LK, base = 10._RKD)
55logSpace_RKD
56+10.000000000000000, +100.00000000000000, +1000.0000000000000, +10000.000000000000
57call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, lopen = .true._LK, base = 10._RKD)
58logSpace_RKD
59+1.0000000000000000, +10.000000000000000, +100.00000000000000, +1000.0000000000000
60call setLogSpace(logSpace_RKD, 0._RKD, 4._RKD, fopen = .true._LK, lopen = .true._LK, base = 10._RKD)
61logSpace_RKD
62+3.1622776601683795, +31.622776601683793, +316.22776601683796, +3162.2776601683790
63call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD)
64logSpace_RKD
65+54.598150033144243, +14.391916095149897, +3.7936678946831783, +1.0000000000000000
66call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, base = 10._RKD)
67logSpace_RKD
68+10000.000000000000, +464.15888336127824, +21.544346900318843, +1.0000000000000000
69call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, fopen = .true._LK, base = 10._RKD)
70logSpace_RKD
71+1000.0000000000000, +100.00000000000000, +10.000000000000000, +1.0000000000000000
72call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, lopen = .true._LK, base = 10._RKD)
73logSpace_RKD
74+10000.000000000000, +1000.0000000000000, +100.00000000000000, +10.000000000000000
75call setLogSpace(logSpace_RKD, 4._RKD, 0._RKD, fopen = .true._LK, lopen = .true._LK, base = 10._RKD)
76logSpace_RKD
77+3162.2776601683790, +316.22776601683796, +31.622776601683793, +3.1622776601683795
78
79!%%%%%%%%%%%
80128-bit real
81!%%%%%%%%%%%
82
83call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH)
84logSpace_RKH
85+1.00000000000000000000000000000000000, +3.79366789468317773539630436050516497, +14.3919160951498941178039062555425154, +54.5981500331442390781102612028608809
86call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, base = 10._RKH)
87logSpace_RKH
88+1.00000000000000000000000000000000000, +21.5443469003188372175929356651935007, +464.158883361277889241007635091944523, +10000.0000000000000000000000000000000
89call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, fopen = .true._LK, base = 10._RKH)
90logSpace_RKH
91+10.0000000000000000000000000000000000, +100.000000000000000000000000000000000, +1000.00000000000000000000000000000000, +10000.0000000000000000000000000000000
92call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, lopen = .true._LK, base = 10._RKH)
93logSpace_RKH
94+1.00000000000000000000000000000000000, +10.0000000000000000000000000000000000, +100.000000000000000000000000000000000, +1000.00000000000000000000000000000000
95call setLogSpace(logSpace_RKH, 0._RKH, 4._RKH, fopen = .true._LK, lopen = .true._LK, base = 10._RKH)
96logSpace_RKH
97+3.16227766016837933199889354443271854, +31.6227766016837933199889354443271854, +316.227766016837933199889354443271860, +3162.27766016837933199889354443271840
98call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH)
99logSpace_RKH
100+54.5981500331442390781102612028608809, +14.3919160951498941178039062555425215, +3.79366789468317773539630436050516574, +1.00000000000000000000000000000000000
101call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, base = 10._RKH)
102logSpace_RKH
103+10000.0000000000000000000000000000000, +464.158883361277889241007635091944917, +21.5443469003188372175929356651935130, +1.00000000000000000000000000000000000
104call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, fopen = .true._LK, base = 10._RKH)
105logSpace_RKH
106+1000.00000000000000000000000000000000, +100.000000000000000000000000000000000, +10.0000000000000000000000000000000000, +1.00000000000000000000000000000000000
107call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, lopen = .true._LK, base = 10._RKH)
108logSpace_RKH
109+10000.0000000000000000000000000000000, +1000.00000000000000000000000000000000, +100.000000000000000000000000000000000, +10.0000000000000000000000000000000000
110call setLogSpace(logSpace_RKH, 4._RKH, 0._RKH, fopen = .true._LK, lopen = .true._LK, base = 10._RKH)
111logSpace_RKH
112+3162.27766016837933199889354443271840, +316.227766016837933199889354443271860, +31.6227766016837933199889354443271854, +3.16227766016837933199889354443271854
113
114!%%%%%%%%%%%%%%%%%%%%%%%%%
115!%%%%%%%%%%%%%%%%%%%%%%%%%
116Generate complex logspace.
117!%%%%%%%%%%%%%%%%%%%%%%%%%
118!%%%%%%%%%%%%%%%%%%%%%%%%%
119
120
121!%%%%%%%%%%%%%
12232-bit complex
123!%%%%%%%%%%%%%
124
125call setLogSpace(logSpace_CKS, (1._CKS,1._CKS), (4._CKS,4._CKS))
126logSpace_CKS
127(+1.46869385, +2.28735518), (-3.07493234, +6.71884966), (-19.8845310, +2.83447099), (-35.6877289, -41.3200150)
128call setLogSpace(logSpace_CKS, (1._CKS,1._CKS), (4._CKS,4._CKS), base = 10._CKS)
129logSpace_CKS
130(-6.68201542, +7.43980312), (-10.7013426, -99.4257660), (+811.214722, +584.748657), (-9770.96387, +2127.97827)
131call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), fopen = .true._LK, base = 10._CKS)
132logSpace_CKS
133(-6.68201542, +7.43980312), (-10.7013426, -99.4257660), (+811.214722, +584.748657), (-9770.96387, +2127.97827)
134call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), lopen = .true._LK, base = 10._CKS)
135logSpace_CKS
136(+1.00000000, +0.00000000), (-6.68201542, +7.43980312), (-10.7013426, -99.4257660), (+811.214722, +584.748657)
137call setLogSpace(logSpace_CKS, (0._CKS,0._CKS), (4._CKS,4._CKS), fopen = .true._LK, lopen = .true._LK, base = 10._CKS)
138logSpace_CKS
139(+1.28801882, +2.88808036), (-30.0933094, -9.71559143), (+273.366180, -158.968567), (-643.940369, +3096.01978)
140call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS))
141logSpace_CKS
142(-35.6877289, +41.3200150), (+0.892413497, -3.68720937), (+0.620079003E-1, +0.256200016), (-0.119719002E-1, -0.138613218E-1)
143call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), base = 10._CKS)
144logSpace_CKS
145(-9770.96387, -2127.97827), (-21.4893303, -1.53866231), (-0.462973453E-1, +0.331492419E-2), (-0.977096133E-4, +0.212797786E-4)
146call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), fopen = .true._LK, base = 10._CKS)
147logSpace_CKS
148(-10.7013426, +99.4257660), (+1.00000000, +0.00000000), (-0.107013423E-2, -0.994257536E-2), (-0.977096133E-4, +0.212797786E-4)
149call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), lopen = .true._LK, base = 10._CKS)
150logSpace_CKS
151(-9770.96387, -2127.97827), (-10.7013426, +99.4257660), (+1.00000000, +0.00000000), (-0.107013423E-2, -0.994257536E-2)
152call setLogSpace(logSpace_CKS, (4._CKS,-4._CKS), (-4._CKS,+4._CKS), fopen = .true._LK, lopen = .true._LK, base = 10._CKS)
153logSpace_CKS
154(+811.214722, -584.748657), (-6.68201542, -7.43980312), (-0.668201521E-1, +0.743980259E-1), (+0.811214559E-3, +0.584748515E-3)
155
156!%%%%%%%%%%%%%
15764-bit complex
158!%%%%%%%%%%%%%
159
160call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD))
161logSpace_CKD
162(+1.0000000000000000, +0.0000000000000000), (+0.89241322946273149, +3.6872096120277442), (-12.799113350909687, +6.5810292751514092), (-35.687732480119131, -41.320016184280199)
163call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), base = 10._CKD)
164logSpace_CKD
165(+1.0000000000000000, +0.0000000000000000), (-21.489332328145490, +1.5386615780603807), (+459.42392445767968, -66.129619982976592), (-9770.9622867323469, +2127.9793211529018)
166call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), fopen = .true._LK, base = 10._CKD)
167logSpace_CKD
168(-6.6820151019031329, +7.4398033695749310), (-10.701348355876982, -99.425756941379021), (+811.21465283970610, +584.74848184339612), (-9770.9622867323469, +2127.9793211529018)
169call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), lopen = .true._LK, base = 10._CKD)
170logSpace_CKD
171(+1.0000000000000000, +0.0000000000000000), (-6.6820151019031329, +7.4398033695749310), (-10.701348355876982, -99.425756941379021), (+811.21465283970610, +584.74848184339612)
172call setLogSpace(logSpace_CKD, (0._CKD,0._CKD), (4._CKD,4._CKD), fopen = .true._LK, lopen = .true._LK, base = 10._CKD)
173logSpace_CKD
174(+1.2880188077230994, +2.8880802535510623), (-30.093310326713034, -9.7155892039622227), (+273.36602736639816, -158.96859778558107), (-643.94081374776601, +3096.0200626594578)
175call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD))
176logSpace_CKD
177(-35.687732480119131, +41.320016184280199), (+0.89241322946273083, -3.6872096120277456), (+0.62007951099956576E-1, +0.25620004922557482), (-0.11971900521662590E-1, -0.13861321214152955E-1)
178call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), base = 10._CKD)
179logSpace_CKD
180(-9770.9622867323469, -2127.9793211529018), (-21.489332328145501, -1.5386615780603718), (-0.46297363033380279E-1, +0.33149458799925278E-2), (-0.97709622867323293E-4, +0.21279793211528979E-4)
181call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), fopen = .true._LK, base = 10._CKD)
182logSpace_CKD
183(-10.701348355876982, +99.425756941379021), (+1.0000000000000000, +0.0000000000000000), (-0.10701348355876973E-2, -0.99425756941378916E-2), (-0.97709622867323293E-4, +0.21279793211528979E-4)
184call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), lopen = .true._LK, base = 10._CKD)
185logSpace_CKD
186(-9770.9622867323469, -2127.9793211529018), (-10.701348355876982, +99.425756941379021), (+1.0000000000000000, +0.0000000000000000), (-0.10701348355876973E-2, -0.99425756941378916E-2)
187call setLogSpace(logSpace_CKD, (4._CKD,-4._CKD), (-4._CKD,+4._CKD), fopen = .true._LK, lopen = .true._LK, base = 10._CKD)
188logSpace_CKD
189(+811.21465283970610, -584.74848184339612), (-6.6820151019031329, -7.4398033695749310), (-0.66820151019031299E-1, +0.74398033695749280E-1), (+0.81121465283970503E-3, +0.58474848184339532E-3)
190
191!%%%%%%%%%%%%%%
192128-bit complex
193!%%%%%%%%%%%%%%
194
195call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH))
196logSpace_CKH
197(+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (+0.892413229462731277425040840529798690, +3.68720961202774484328620605149881354), (-12.7991133509096911815909637775114086, +6.58102927515140845418525943409442629), (-35.6877324801191332990417139972871190, -41.3200161842802056970774483238470197)
198call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), base = 10._CKH)
199logSpace_CKH
200(+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (-21.4893323281454840556173421890123814, +1.53866157806038661667621752314532881), (+459.423924457679330805379902128061207, -66.1296199829768247690351798309956726), (-9770.96228673233636876178613204470709, +2127.97932115290822526867517647758867)
201call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), fopen = .true._LK, base = 10._CKH)
202logSpace_CKH
203(-6.68201510190312946242330696656142377, +7.43980336957493187658416406875514362), (-10.7013483558770207720865175285182452, -99.4257569413789687361619371909155975), (+811.214652839705902013971782701663845, +584.748481843395154894261429590175230), (-9770.96228673233636876178613204470709, +2127.97932115290822526867517647758867)
204call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), lopen = .true._LK, base = 10._CKH)
205logSpace_CKH
206(+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (-6.68201510190312946242330696656142377, +7.43980336957493187658416406875514362), (-10.7013483558770207720865175285182452, -99.4257569413789687361619371909155975), (+811.214652839705902013971782701663845, +584.748481843395154894261429590175230)
207call setLogSpace(logSpace_CKH, (0._CKH,0._CKH), (4._CKH,4._CKH), fopen = .true._LK, lopen = .true._LK, base = 10._CKH)
208logSpace_CKH
209(+1.28801880772309969743534705401557004, +2.88808025355106168164849546968240769), (-30.0933103267130276507566541305484520, -9.71558920396220997988032474265712857), (+273.366027366397729523842506149183534, -158.968597785581186217262923638309952), (-643.940813747764838905612522510823629, +3096.02006265945673923907800548861768)
210call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH))
211logSpace_CKH
212(-35.6877324801191332990417139972871190, +41.3200161842802056970774483238470197), (+0.892413229462731277425040840529798208, -3.68720961202774484328620605149881431), (+0.620079510999564822225351575123949535E-1, +0.256200049225574780070743677010013931), (-0.119719005216625907934578427957440421E-1, -0.138613212141529576938462541587188533E-1)
213call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), base = 10._CKH)
214logSpace_CKH
215(-9770.96228673233636876178613204470709, -2127.97932115290822526867517647758867), (-21.4893323281454840556173421890123906, -1.53866157806038661667621752314532130), (-0.462973630333802541090074742242052579E-1, +0.331494587999249809941556845516021446E-2), (-0.977096228673233636876178613204470924E-4, +0.212797932115290822526867517647758938E-4)
216call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), fopen = .true._LK, base = 10._CKH)
217logSpace_CKH
218(-10.7013483558770207720865175285182452, +99.4257569413789687361619371909155975), (+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (-0.107013483558770207720865175285182464E-2, -0.994257569413789687361619371909156077E-2), (-0.977096228673233636876178613204470924E-4, +0.212797932115290822526867517647758938E-4)
219call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), lopen = .true._LK, base = 10._CKH)
220logSpace_CKH
221(-9770.96228673233636876178613204470709, -2127.97932115290822526867517647758867), (-10.7013483558770207720865175285182452, +99.4257569413789687361619371909155975), (+1.00000000000000000000000000000000000, +0.00000000000000000000000000000000000), (-0.107013483558770207720865175285182464E-2, -0.994257569413789687361619371909156077E-2)
222call setLogSpace(logSpace_CKH, (4._CKH,-4._CKH), (-4._CKH,+4._CKH), fopen = .true._LK, lopen = .true._LK, base = 10._CKH)
223logSpace_CKH
224(+811.214652839705902013971782701663845, -584.748481843395154894261429590175230), (-6.68201510190312946242330696656142377, -7.43980336957493187658416406875514362), (-0.668201510190312946242330696656142353E-1, +0.743980336957493187658416406875514424E-1), (+0.811214652839705902013971782701664105E-3, +0.584748481843395154894261429590175425E-3)
225
Test:
test_pm_arraySpace
Todo:
Low Priority: This generic interface can be expanded to include procedures with real-valued input argument space instead of count.


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.

  1. 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.
  2. 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.

Author:
Fatemeh Bagheri, Tuesday 11:34 PM, August 10, 2021, Dallas, TX

Definition at line 768 of file pm_arraySpace.F90.


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