gtool5 Fortran 90/95 Library 1.0.0-rc5
日本語
Loading...
Searching...
No Matches
Functions/Subroutines
dcstringputline.f90 File Reference

Go to the source code of this file.

Functions/Subroutines

subroutine putlineint1 (array, lbounds, ubounds, unit, indent, sd)
 Print array summary (PutLine subroutines).
subroutine putlineint2 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlineint3 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlineint4 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlineint5 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlineint6 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlineint7 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinereal1 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinereal2 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinereal3 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinereal4 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinereal5 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinereal6 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinereal7 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinedouble1 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinedouble2 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinedouble3 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinedouble4 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinedouble5 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinedouble6 (array, lbounds, ubounds, unit, indent, sd)
subroutine putlinedouble7 (array, lbounds, ubounds, unit, indent, sd)

Function/Subroutine Documentation

◆ putlinedouble1()

subroutine putlinedouble1 ( real(dp), dimension(:), intent(in) array,
integer, dimension(1), intent(in), optional lbounds,
integer, dimension(1), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 1-dimensional double array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array1-dimensional double array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 2014 of file dcstringputline.f90.

2015 use dc_types, only: dp, string, stdout
2016 use dc_string, only: tochar, printf, cprintf
2017 use dc_present, only: present_and_true
2018 implicit none
2019 real(DP), intent(in):: array(:)
2020 integer, intent(in), optional:: lbounds(1)
2021 integer, intent(in), optional:: ubounds(1)
2022 integer, intent(in), optional:: unit
2023 character(*), intent(in), optional:: indent
2024 logical, intent(in), optional:: sd
2025 integer:: out_unit
2026 integer:: indent_len
2027 character(STRING):: indent_str
2028 integer:: i
2029 integer:: alldim_size, lbound_nums(1), ubound_nums(1)
2030 character(STRING):: size_str, sd_str
2031 real(DP) :: max_value, min_value
2032 real(DP), allocatable :: array_packed(:)
2033 real(DP) :: avg_value, variance_value, sd_value
2034 continue
2035 !-----------------------------------------------------------------
2036 ! オプショナル引数のチェック
2037 ! Check optional arguments
2038 !-----------------------------------------------------------------
2039 if ( present(unit) ) then
2040 out_unit = unit
2041 else
2042 out_unit = stdout
2043 end if
2044 indent_len = 0
2045 indent_str = ''
2046 if ( present(indent) ) then
2047 if (len(indent) /= 0) then
2048 indent_len = len(indent)
2049 indent_str(1:indent_len) = indent
2050 end if
2051 end if
2052 !-------------------------------------------------------------------
2053 ! 配列サイズ
2054 ! Array size
2055 !-------------------------------------------------------------------
2056 if ( present(lbounds) .and. present(ubounds) ) then
2057 lbound_nums = lbounds
2058 ubound_nums = ubounds
2059 else
2060 lbound_nums(1) = lbound( array, 1 )
2061 ubound_nums(1) = ubound( array, 1 )
2062 end if
2063 size_str = '('
2064 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
2065 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
2066 size_str = trim(size_str) // ')'
2067 !-------------------------------------------------------------------
2068 ! 最大値
2069 ! Maximum value
2070 !-------------------------------------------------------------------
2071 max_value = maxval(array)
2072 !-------------------------------------------------------------------
2073 ! 最小値
2074 ! Minimum value
2075 !-------------------------------------------------------------------
2076 min_value = minval(array)
2077 !-------------------------------------------------------------------
2078 ! 平均値
2079 ! Average value
2080 !-------------------------------------------------------------------
2081 alldim_size = size(array)
2082 avg_value = sum(array) / dble(alldim_size)
2083 !-------------------------------------------------------------------
2084 ! 標準偏差
2085 ! Standard deviation
2086 !-------------------------------------------------------------------
2087 sd_value = 0.0d0
2088 variance_value = 0.0d0
2089 sd_str = ''
2090 if ( present_and_true( sd ) ) then
2091 if ( alldim_size > 1 ) then
2092 if (allocated(array_packed)) then
2093 deallocate(array_packed)
2094 end if
2095 allocate( array_packed(alldim_size) )
2096 array_packed = array
2097 do i = 1, alldim_size
2098 variance_value = variance_value + &
2099 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
2100 end do
2101 variance_value = variance_value / dble(alldim_size)
2102 sd_value = sqrt( variance_value )
2103 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
2104 end if
2105 end if
2106 !-------------------------------------------------------------------
2107 ! 印字
2108 ! Print
2109 !-------------------------------------------------------------------
2110 call printf(out_unit, &
2111 & indent_str(1:indent_len) // &
2112 & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
2113 & d = (/max_value, min_value, avg_value/), &
2114 & c1 = trim(size_str), c2 = trim(sd_str) )
dc_string::cprintf
Definition dc_string.f90:213
dc_string::printf
Definition dc_string.f90:241
dc_string::tochar
Definition dc_string.f90:130
dc_present
Judge optional control parameters.
Definition dc_present.f90:59
dc_present::present_and_true
logical function, public present_and_true(arg)
Definition dc_present.f90:103
dc_string
Handling character types.
Definition dc_string.f90:83
dc_types
Provides kind type parameter values.
Definition dc_types.f90:55
dc_types::string
integer, parameter, public string
Character length for string
Definition dc_types.f90:137
dc_types::stdout
integer, parameter, public stdout
Unit number for Standard OUTPUT
Definition dc_types.f90:117
dc_types::dp
integer, parameter, public dp
Double Precision Real number
Definition dc_types.f90:92

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinedouble2()

subroutine putlinedouble2 ( real(dp), dimension(:,:), intent(in) array,
integer, dimension(2), intent(in), optional lbounds,
integer, dimension(2), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 2-dimensional double array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array2-dimensional double array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 2141 of file dcstringputline.f90.

2142 use dc_types, only: dp, string, stdout
2143 use dc_string, only: tochar, printf, cprintf
2144 use dc_present, only: present_and_true
2145 implicit none
2146 real(DP), intent(in):: array(:,:)
2147 integer, intent(in), optional:: lbounds(2)
2148 integer, intent(in), optional:: ubounds(2)
2149 integer, intent(in), optional:: unit
2150 character(*), intent(in), optional:: indent
2151 logical, intent(in), optional:: sd
2152 integer:: out_unit
2153 integer:: indent_len
2154 character(STRING):: indent_str
2155 integer:: i
2156 integer:: alldim_size, lbound_nums(2), ubound_nums(2)
2157 character(STRING):: size_str, sd_str
2158 real(DP) :: max_value, min_value
2159 real(DP), allocatable :: array_packed(:)
2160 real(DP) :: avg_value, variance_value, sd_value
2161 continue
2162 !-----------------------------------------------------------------
2163 ! オプショナル引数のチェック
2164 ! Check optional arguments
2165 !-----------------------------------------------------------------
2166 if ( present(unit) ) then
2167 out_unit = unit
2168 else
2169 out_unit = stdout
2170 end if
2171 indent_len = 0
2172 indent_str = ''
2173 if ( present(indent) ) then
2174 if (len(indent) /= 0) then
2175 indent_len = len(indent)
2176 indent_str(1:indent_len) = indent
2177 end if
2178 end if
2179 !-------------------------------------------------------------------
2180 ! 配列サイズ
2181 ! Array size
2182 !-------------------------------------------------------------------
2183 if ( present(lbounds) .and. present(ubounds) ) then
2184 lbound_nums = lbounds
2185 ubound_nums = ubounds
2186 else
2187 lbound_nums(1) = lbound( array, 1 )
2188 ubound_nums(1) = ubound( array, 1 )
2189 lbound_nums(2) = lbound( array, 2 )
2190 ubound_nums(2) = ubound( array, 2 )
2191 end if
2192 size_str = '('
2193 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
2194 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
2195 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
2196 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
2197 size_str = trim(size_str) // ')'
2198 !-------------------------------------------------------------------
2199 ! 最大値
2200 ! Maximum value
2201 !-------------------------------------------------------------------
2202 max_value = maxval(array)
2203 !-------------------------------------------------------------------
2204 ! 最小値
2205 ! Minimum value
2206 !-------------------------------------------------------------------
2207 min_value = minval(array)
2208 !-------------------------------------------------------------------
2209 ! 平均値
2210 ! Average value
2211 !-------------------------------------------------------------------
2212 alldim_size = size(array)
2213 avg_value = sum(array) / dble(alldim_size)
2214 !-------------------------------------------------------------------
2215 ! 標準偏差
2216 ! Standard deviation
2217 !-------------------------------------------------------------------
2218 sd_value = 0.0d0
2219 variance_value = 0.0d0
2220 sd_str = ''
2221 if ( present_and_true( sd ) ) then
2222 if ( alldim_size > 1 ) then
2223 if (allocated(array_packed)) then
2224 deallocate(array_packed)
2225 end if
2226 allocate( array_packed(alldim_size) )
2227 array_packed = pack(array, .true.)
2228 do i = 1, alldim_size
2229 variance_value = variance_value + &
2230 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
2231 end do
2232 variance_value = variance_value / dble(alldim_size)
2233 sd_value = sqrt( variance_value )
2234 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
2235 end if
2236 end if
2237 !-------------------------------------------------------------------
2238 ! 印字
2239 ! Print
2240 !-------------------------------------------------------------------
2241 call printf(out_unit, &
2242 & indent_str(1:indent_len) // &
2243 & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
2244 & d = (/max_value, min_value, avg_value/), &
2245 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinedouble3()

subroutine putlinedouble3 ( real(dp), dimension(:,:,:), intent(in) array,
integer, dimension(3), intent(in), optional lbounds,
integer, dimension(3), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 3-dimensional double array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array3-dimensional double array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 2272 of file dcstringputline.f90.

2273 use dc_types, only: dp, string, stdout
2274 use dc_string, only: tochar, printf, cprintf
2275 use dc_present, only: present_and_true
2276 implicit none
2277 real(DP), intent(in):: array(:,:,:)
2278 integer, intent(in), optional:: lbounds(3)
2279 integer, intent(in), optional:: ubounds(3)
2280 integer, intent(in), optional:: unit
2281 character(*), intent(in), optional:: indent
2282 logical, intent(in), optional:: sd
2283 integer:: out_unit
2284 integer:: indent_len
2285 character(STRING):: indent_str
2286 integer:: i
2287 integer:: alldim_size, lbound_nums(3), ubound_nums(3)
2288 character(STRING):: size_str, sd_str
2289 real(DP) :: max_value, min_value
2290 real(DP), allocatable :: array_packed(:)
2291 real(DP) :: avg_value, variance_value, sd_value
2292 continue
2293 !-----------------------------------------------------------------
2294 ! オプショナル引数のチェック
2295 ! Check optional arguments
2296 !-----------------------------------------------------------------
2297 if ( present(unit) ) then
2298 out_unit = unit
2299 else
2300 out_unit = stdout
2301 end if
2302 indent_len = 0
2303 indent_str = ''
2304 if ( present(indent) ) then
2305 if (len(indent) /= 0) then
2306 indent_len = len(indent)
2307 indent_str(1:indent_len) = indent
2308 end if
2309 end if
2310 !-------------------------------------------------------------------
2311 ! 配列サイズ
2312 ! Array size
2313 !-------------------------------------------------------------------
2314 if ( present(lbounds) .and. present(ubounds) ) then
2315 lbound_nums = lbounds
2316 ubound_nums = ubounds
2317 else
2318 lbound_nums(1) = lbound( array, 1 )
2319 ubound_nums(1) = ubound( array, 1 )
2320 lbound_nums(2) = lbound( array, 2 )
2321 ubound_nums(2) = ubound( array, 2 )
2322 lbound_nums(3) = lbound( array, 3 )
2323 ubound_nums(3) = ubound( array, 3 )
2324 end if
2325 size_str = '('
2326 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
2327 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
2328 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
2329 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
2330 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
2331 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
2332 size_str = trim(size_str) // ')'
2333 !-------------------------------------------------------------------
2334 ! 最大値
2335 ! Maximum value
2336 !-------------------------------------------------------------------
2337 max_value = maxval(array)
2338 !-------------------------------------------------------------------
2339 ! 最小値
2340 ! Minimum value
2341 !-------------------------------------------------------------------
2342 min_value = minval(array)
2343 !-------------------------------------------------------------------
2344 ! 平均値
2345 ! Average value
2346 !-------------------------------------------------------------------
2347 alldim_size = size(array)
2348 avg_value = sum(array) / dble(alldim_size)
2349 !-------------------------------------------------------------------
2350 ! 標準偏差
2351 ! Standard deviation
2352 !-------------------------------------------------------------------
2353 sd_value = 0.0d0
2354 variance_value = 0.0d0
2355 sd_str = ''
2356 if ( present_and_true( sd ) ) then
2357 if ( alldim_size > 1 ) then
2358 if (allocated(array_packed)) then
2359 deallocate(array_packed)
2360 end if
2361 allocate( array_packed(alldim_size) )
2362 array_packed = pack(array, .true.)
2363 do i = 1, alldim_size
2364 variance_value = variance_value + &
2365 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
2366 end do
2367 variance_value = variance_value / dble(alldim_size)
2368 sd_value = sqrt( variance_value )
2369 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
2370 end if
2371 end if
2372 !-------------------------------------------------------------------
2373 ! 印字
2374 ! Print
2375 !-------------------------------------------------------------------
2376 call printf(out_unit, &
2377 & indent_str(1:indent_len) // &
2378 & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
2379 & d = (/max_value, min_value, avg_value/), &
2380 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinedouble4()

subroutine putlinedouble4 ( real(dp), dimension(:,:,:,:), intent(in) array,
integer, dimension(4), intent(in), optional lbounds,
integer, dimension(4), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 4-dimensional double array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array4-dimensional double array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 2407 of file dcstringputline.f90.

2408 use dc_types, only: dp, string, stdout
2409 use dc_string, only: tochar, printf, cprintf
2410 use dc_present, only: present_and_true
2411 implicit none
2412 real(DP), intent(in):: array(:,:,:,:)
2413 integer, intent(in), optional:: lbounds(4)
2414 integer, intent(in), optional:: ubounds(4)
2415 integer, intent(in), optional:: unit
2416 character(*), intent(in), optional:: indent
2417 logical, intent(in), optional:: sd
2418 integer:: out_unit
2419 integer:: indent_len
2420 character(STRING):: indent_str
2421 integer:: i
2422 integer:: alldim_size, lbound_nums(4), ubound_nums(4)
2423 character(STRING):: size_str, sd_str
2424 real(DP) :: max_value, min_value
2425 real(DP), allocatable :: array_packed(:)
2426 real(DP) :: avg_value, variance_value, sd_value
2427 continue
2428 !-----------------------------------------------------------------
2429 ! オプショナル引数のチェック
2430 ! Check optional arguments
2431 !-----------------------------------------------------------------
2432 if ( present(unit) ) then
2433 out_unit = unit
2434 else
2435 out_unit = stdout
2436 end if
2437 indent_len = 0
2438 indent_str = ''
2439 if ( present(indent) ) then
2440 if (len(indent) /= 0) then
2441 indent_len = len(indent)
2442 indent_str(1:indent_len) = indent
2443 end if
2444 end if
2445 !-------------------------------------------------------------------
2446 ! 配列サイズ
2447 ! Array size
2448 !-------------------------------------------------------------------
2449 if ( present(lbounds) .and. present(ubounds) ) then
2450 lbound_nums = lbounds
2451 ubound_nums = ubounds
2452 else
2453 lbound_nums(1) = lbound( array, 1 )
2454 ubound_nums(1) = ubound( array, 1 )
2455 lbound_nums(2) = lbound( array, 2 )
2456 ubound_nums(2) = ubound( array, 2 )
2457 lbound_nums(3) = lbound( array, 3 )
2458 ubound_nums(3) = ubound( array, 3 )
2459 lbound_nums(4) = lbound( array, 4 )
2460 ubound_nums(4) = ubound( array, 4 )
2461 end if
2462 size_str = '('
2463 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
2464 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
2465 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
2466 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
2467 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
2468 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
2469 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
2470 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
2471 size_str = trim(size_str) // ')'
2472 !-------------------------------------------------------------------
2473 ! 最大値
2474 ! Maximum value
2475 !-------------------------------------------------------------------
2476 max_value = maxval(array)
2477 !-------------------------------------------------------------------
2478 ! 最小値
2479 ! Minimum value
2480 !-------------------------------------------------------------------
2481 min_value = minval(array)
2482 !-------------------------------------------------------------------
2483 ! 平均値
2484 ! Average value
2485 !-------------------------------------------------------------------
2486 alldim_size = size(array)
2487 avg_value = sum(array) / dble(alldim_size)
2488 !-------------------------------------------------------------------
2489 ! 標準偏差
2490 ! Standard deviation
2491 !-------------------------------------------------------------------
2492 sd_value = 0.0d0
2493 variance_value = 0.0d0
2494 sd_str = ''
2495 if ( present_and_true( sd ) ) then
2496 if ( alldim_size > 1 ) then
2497 if (allocated(array_packed)) then
2498 deallocate(array_packed)
2499 end if
2500 allocate( array_packed(alldim_size) )
2501 array_packed = pack(array, .true.)
2502 do i = 1, alldim_size
2503 variance_value = variance_value + &
2504 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
2505 end do
2506 variance_value = variance_value / dble(alldim_size)
2507 sd_value = sqrt( variance_value )
2508 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
2509 end if
2510 end if
2511 !-------------------------------------------------------------------
2512 ! 印字
2513 ! Print
2514 !-------------------------------------------------------------------
2515 call printf(out_unit, &
2516 & indent_str(1:indent_len) // &
2517 & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
2518 & d = (/max_value, min_value, avg_value/), &
2519 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinedouble5()

subroutine putlinedouble5 ( real(dp), dimension(:,:,:,:,:), intent(in) array,
integer, dimension(5), intent(in), optional lbounds,
integer, dimension(5), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 5-dimensional double array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array5-dimensional double array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 2546 of file dcstringputline.f90.

2547 use dc_types, only: dp, string, stdout
2548 use dc_string, only: tochar, printf, cprintf
2549 use dc_present, only: present_and_true
2550 implicit none
2551 real(DP), intent(in):: array(:,:,:,:,:)
2552 integer, intent(in), optional:: lbounds(5)
2553 integer, intent(in), optional:: ubounds(5)
2554 integer, intent(in), optional:: unit
2555 character(*), intent(in), optional:: indent
2556 logical, intent(in), optional:: sd
2557 integer:: out_unit
2558 integer:: indent_len
2559 character(STRING):: indent_str
2560 integer:: i
2561 integer:: alldim_size, lbound_nums(5), ubound_nums(5)
2562 character(STRING):: size_str, sd_str
2563 real(DP) :: max_value, min_value
2564 real(DP), allocatable :: array_packed(:)
2565 real(DP) :: avg_value, variance_value, sd_value
2566 continue
2567 !-----------------------------------------------------------------
2568 ! オプショナル引数のチェック
2569 ! Check optional arguments
2570 !-----------------------------------------------------------------
2571 if ( present(unit) ) then
2572 out_unit = unit
2573 else
2574 out_unit = stdout
2575 end if
2576 indent_len = 0
2577 indent_str = ''
2578 if ( present(indent) ) then
2579 if (len(indent) /= 0) then
2580 indent_len = len(indent)
2581 indent_str(1:indent_len) = indent
2582 end if
2583 end if
2584 !-------------------------------------------------------------------
2585 ! 配列サイズ
2586 ! Array size
2587 !-------------------------------------------------------------------
2588 if ( present(lbounds) .and. present(ubounds) ) then
2589 lbound_nums = lbounds
2590 ubound_nums = ubounds
2591 else
2592 lbound_nums(1) = lbound( array, 1 )
2593 ubound_nums(1) = ubound( array, 1 )
2594 lbound_nums(2) = lbound( array, 2 )
2595 ubound_nums(2) = ubound( array, 2 )
2596 lbound_nums(3) = lbound( array, 3 )
2597 ubound_nums(3) = ubound( array, 3 )
2598 lbound_nums(4) = lbound( array, 4 )
2599 ubound_nums(4) = ubound( array, 4 )
2600 lbound_nums(5) = lbound( array, 5 )
2601 ubound_nums(5) = ubound( array, 5 )
2602 end if
2603 size_str = '('
2604 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
2605 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
2606 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
2607 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
2608 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
2609 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
2610 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
2611 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
2612 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
2613 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
2614 size_str = trim(size_str) // ')'
2615 !-------------------------------------------------------------------
2616 ! 最大値
2617 ! Maximum value
2618 !-------------------------------------------------------------------
2619 max_value = maxval(array)
2620 !-------------------------------------------------------------------
2621 ! 最小値
2622 ! Minimum value
2623 !-------------------------------------------------------------------
2624 min_value = minval(array)
2625 !-------------------------------------------------------------------
2626 ! 平均値
2627 ! Average value
2628 !-------------------------------------------------------------------
2629 alldim_size = size(array)
2630 avg_value = sum(array) / dble(alldim_size)
2631 !-------------------------------------------------------------------
2632 ! 標準偏差
2633 ! Standard deviation
2634 !-------------------------------------------------------------------
2635 sd_value = 0.0d0
2636 variance_value = 0.0d0
2637 sd_str = ''
2638 if ( present_and_true( sd ) ) then
2639 if ( alldim_size > 1 ) then
2640 if (allocated(array_packed)) then
2641 deallocate(array_packed)
2642 end if
2643 allocate( array_packed(alldim_size) )
2644 array_packed = pack(array, .true.)
2645 do i = 1, alldim_size
2646 variance_value = variance_value + &
2647 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
2648 end do
2649 variance_value = variance_value / dble(alldim_size)
2650 sd_value = sqrt( variance_value )
2651 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
2652 end if
2653 end if
2654 !-------------------------------------------------------------------
2655 ! 印字
2656 ! Print
2657 !-------------------------------------------------------------------
2658 call printf(out_unit, &
2659 & indent_str(1:indent_len) // &
2660 & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
2661 & d = (/max_value, min_value, avg_value/), &
2662 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinedouble6()

subroutine putlinedouble6 ( real(dp), dimension(:,:,:,:,:,:), intent(in) array,
integer, dimension(6), intent(in), optional lbounds,
integer, dimension(6), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 6-dimensional double array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array6-dimensional double array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 2689 of file dcstringputline.f90.

2690 use dc_types, only: dp, string, stdout
2691 use dc_string, only: tochar, printf, cprintf
2692 use dc_present, only: present_and_true
2693 implicit none
2694 real(DP), intent(in):: array(:,:,:,:,:,:)
2695 integer, intent(in), optional:: lbounds(6)
2696 integer, intent(in), optional:: ubounds(6)
2697 integer, intent(in), optional:: unit
2698 character(*), intent(in), optional:: indent
2699 logical, intent(in), optional:: sd
2700 integer:: out_unit
2701 integer:: indent_len
2702 character(STRING):: indent_str
2703 integer:: i
2704 integer:: alldim_size, lbound_nums(6), ubound_nums(6)
2705 character(STRING):: size_str, sd_str
2706 real(DP) :: max_value, min_value
2707 real(DP), allocatable :: array_packed(:)
2708 real(DP) :: avg_value, variance_value, sd_value
2709 continue
2710 !-----------------------------------------------------------------
2711 ! オプショナル引数のチェック
2712 ! Check optional arguments
2713 !-----------------------------------------------------------------
2714 if ( present(unit) ) then
2715 out_unit = unit
2716 else
2717 out_unit = stdout
2718 end if
2719 indent_len = 0
2720 indent_str = ''
2721 if ( present(indent) ) then
2722 if (len(indent) /= 0) then
2723 indent_len = len(indent)
2724 indent_str(1:indent_len) = indent
2725 end if
2726 end if
2727 !-------------------------------------------------------------------
2728 ! 配列サイズ
2729 ! Array size
2730 !-------------------------------------------------------------------
2731 if ( present(lbounds) .and. present(ubounds) ) then
2732 lbound_nums = lbounds
2733 ubound_nums = ubounds
2734 else
2735 lbound_nums(1) = lbound( array, 1 )
2736 ubound_nums(1) = ubound( array, 1 )
2737 lbound_nums(2) = lbound( array, 2 )
2738 ubound_nums(2) = ubound( array, 2 )
2739 lbound_nums(3) = lbound( array, 3 )
2740 ubound_nums(3) = ubound( array, 3 )
2741 lbound_nums(4) = lbound( array, 4 )
2742 ubound_nums(4) = ubound( array, 4 )
2743 lbound_nums(5) = lbound( array, 5 )
2744 ubound_nums(5) = ubound( array, 5 )
2745 lbound_nums(6) = lbound( array, 6 )
2746 ubound_nums(6) = ubound( array, 6 )
2747 end if
2748 size_str = '('
2749 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
2750 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
2751 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
2752 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
2753 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
2754 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
2755 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
2756 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
2757 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
2758 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
2759 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
2760 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
2761 size_str = trim(size_str) // ')'
2762 !-------------------------------------------------------------------
2763 ! 最大値
2764 ! Maximum value
2765 !-------------------------------------------------------------------
2766 max_value = maxval(array)
2767 !-------------------------------------------------------------------
2768 ! 最小値
2769 ! Minimum value
2770 !-------------------------------------------------------------------
2771 min_value = minval(array)
2772 !-------------------------------------------------------------------
2773 ! 平均値
2774 ! Average value
2775 !-------------------------------------------------------------------
2776 alldim_size = size(array)
2777 avg_value = sum(array) / dble(alldim_size)
2778 !-------------------------------------------------------------------
2779 ! 標準偏差
2780 ! Standard deviation
2781 !-------------------------------------------------------------------
2782 sd_value = 0.0d0
2783 variance_value = 0.0d0
2784 sd_str = ''
2785 if ( present_and_true( sd ) ) then
2786 if ( alldim_size > 1 ) then
2787 if (allocated(array_packed)) then
2788 deallocate(array_packed)
2789 end if
2790 allocate( array_packed(alldim_size) )
2791 array_packed = pack(array, .true.)
2792 do i = 1, alldim_size
2793 variance_value = variance_value + &
2794 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
2795 end do
2796 variance_value = variance_value / dble(alldim_size)
2797 sd_value = sqrt( variance_value )
2798 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
2799 end if
2800 end if
2801 !-------------------------------------------------------------------
2802 ! 印字
2803 ! Print
2804 !-------------------------------------------------------------------
2805 call printf(out_unit, &
2806 & indent_str(1:indent_len) // &
2807 & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
2808 & d = (/max_value, min_value, avg_value/), &
2809 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinedouble7()

subroutine putlinedouble7 ( real(dp), dimension(:,:,:,:,:,:,:), intent(in) array,
integer, dimension(7), intent(in), optional lbounds,
integer, dimension(7), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 7-dimensional double array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array7-dimensional double array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 2836 of file dcstringputline.f90.

2837 use dc_types, only: dp, string, stdout
2838 use dc_string, only: tochar, printf, cprintf
2839 use dc_present, only: present_and_true
2840 implicit none
2841 real(DP), intent(in):: array(:,:,:,:,:,:,:)
2842 integer, intent(in), optional:: lbounds(7)
2843 integer, intent(in), optional:: ubounds(7)
2844 integer, intent(in), optional:: unit
2845 character(*), intent(in), optional:: indent
2846 logical, intent(in), optional:: sd
2847 integer:: out_unit
2848 integer:: indent_len
2849 character(STRING):: indent_str
2850 integer:: i
2851 integer:: alldim_size, lbound_nums(7), ubound_nums(7)
2852 character(STRING):: size_str, sd_str
2853 real(DP) :: max_value, min_value
2854 real(DP), allocatable :: array_packed(:)
2855 real(DP) :: avg_value, variance_value, sd_value
2856 continue
2857 !-----------------------------------------------------------------
2858 ! オプショナル引数のチェック
2859 ! Check optional arguments
2860 !-----------------------------------------------------------------
2861 if ( present(unit) ) then
2862 out_unit = unit
2863 else
2864 out_unit = stdout
2865 end if
2866 indent_len = 0
2867 indent_str = ''
2868 if ( present(indent) ) then
2869 if (len(indent) /= 0) then
2870 indent_len = len(indent)
2871 indent_str(1:indent_len) = indent
2872 end if
2873 end if
2874 !-------------------------------------------------------------------
2875 ! 配列サイズ
2876 ! Array size
2877 !-------------------------------------------------------------------
2878 if ( present(lbounds) .and. present(ubounds) ) then
2879 lbound_nums = lbounds
2880 ubound_nums = ubounds
2881 else
2882 lbound_nums(1) = lbound( array, 1 )
2883 ubound_nums(1) = ubound( array, 1 )
2884 lbound_nums(2) = lbound( array, 2 )
2885 ubound_nums(2) = ubound( array, 2 )
2886 lbound_nums(3) = lbound( array, 3 )
2887 ubound_nums(3) = ubound( array, 3 )
2888 lbound_nums(4) = lbound( array, 4 )
2889 ubound_nums(4) = ubound( array, 4 )
2890 lbound_nums(5) = lbound( array, 5 )
2891 ubound_nums(5) = ubound( array, 5 )
2892 lbound_nums(6) = lbound( array, 6 )
2893 ubound_nums(6) = ubound( array, 6 )
2894 lbound_nums(7) = lbound( array, 7 )
2895 ubound_nums(7) = ubound( array, 7 )
2896 end if
2897 size_str = '('
2898 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
2899 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
2900 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
2901 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
2902 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
2903 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
2904 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
2905 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
2906 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
2907 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
2908 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
2909 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
2910 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(7)))
2911 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(7)))
2912 size_str = trim(size_str) // ')'
2913 !-------------------------------------------------------------------
2914 ! 最大値
2915 ! Maximum value
2916 !-------------------------------------------------------------------
2917 max_value = maxval(array)
2918 !-------------------------------------------------------------------
2919 ! 最小値
2920 ! Minimum value
2921 !-------------------------------------------------------------------
2922 min_value = minval(array)
2923 !-------------------------------------------------------------------
2924 ! 平均値
2925 ! Average value
2926 !-------------------------------------------------------------------
2927 alldim_size = size(array)
2928 avg_value = sum(array) / dble(alldim_size)
2929 !-------------------------------------------------------------------
2930 ! 標準偏差
2931 ! Standard deviation
2932 !-------------------------------------------------------------------
2933 sd_value = 0.0d0
2934 variance_value = 0.0d0
2935 sd_str = ''
2936 if ( present_and_true( sd ) ) then
2937 if ( alldim_size > 1 ) then
2938 if (allocated(array_packed)) then
2939 deallocate(array_packed)
2940 end if
2941 allocate( array_packed(alldim_size) )
2942 array_packed = pack(array, .true.)
2943 do i = 1, alldim_size
2944 variance_value = variance_value + &
2945 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
2946 end do
2947 variance_value = variance_value / dble(alldim_size)
2948 sd_value = sqrt( variance_value )
2949 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
2950 end if
2951 end if
2952 !-------------------------------------------------------------------
2953 ! 印字
2954 ! Print
2955 !-------------------------------------------------------------------
2956 call printf(out_unit, &
2957 & indent_str(1:indent_len) // &
2958 & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
2959 & d = (/max_value, min_value, avg_value/), &
2960 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlineint1()

subroutine putlineint1 ( integer, dimension(:), intent(in) array,
integer, dimension(1), intent(in), optional lbounds,
integer, dimension(1), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print array summary (PutLine subroutines).

Author
Youhei SASAKI, Yasuhiro MORIKAWA, Eizi TOYODA
Copyright
Copyright (C) GFD Dennou Club, 2000-2026. All rights reserved.
License is BSD-2-Clause. see COPYRIGHT in detail

Important

This file is generated from ../../../../src/dc_utils/dcstringputline.erb by ERB included Ruby 3.3.8. Please do not edit this file directly.

This file contains PutLine subroutines for printing array summaries. Each subroutine prints the array size, maximum value, minimum value, and average value. Optionally, standard deviation can also be printed.

Generated subroutines:

  • PutLineInt1 to PutLineInt7: for integer arrays of 1 to 7 dimensions
  • PutLineReal1 to PutLineReal7: for single precision real arrays of 1 to 7 dimensions
  • PutLineDouble1 to PutLineDouble7: for double precision real arrays of 1 to 7 dimensions

Print summary of 1-dimensional int array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array1-dimensional int array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 68 of file dcstringputline.f90.

69 use dc_types, only: dp, string, stdout
70 use dc_string, only: tochar, printf, cprintf
71 use dc_present, only: present_and_true
72 implicit none
73 integer, intent(in):: array(:)
74 integer, intent(in), optional:: lbounds(1)
75 integer, intent(in), optional:: ubounds(1)
76 integer, intent(in), optional:: unit
77 character(*), intent(in), optional:: indent
78 logical, intent(in), optional:: sd
79 integer:: out_unit
80 integer:: indent_len
81 character(STRING):: indent_str
82 integer:: i
83 integer:: alldim_size, lbound_nums(1), ubound_nums(1)
84 character(STRING):: size_str, sd_str
85 integer:: max_value, min_value
86 integer, allocatable:: array_packed(:)
87 real(DP) :: avg_value, variance_value, sd_value
88 continue
89 !-----------------------------------------------------------------
90 ! オプショナル引数のチェック
91 ! Check optional arguments
92 !-----------------------------------------------------------------
93 if ( present(unit) ) then
94 out_unit = unit
95 else
96 out_unit = stdout
97 end if
98 indent_len = 0
99 indent_str = ''
100 if ( present(indent) ) then
101 if (len(indent) /= 0) then
102 indent_len = len(indent)
103 indent_str(1:indent_len) = indent
104 end if
105 end if
106 !-------------------------------------------------------------------
107 ! 配列サイズ
108 ! Array size
109 !-------------------------------------------------------------------
110 if ( present(lbounds) .and. present(ubounds) ) then
111 lbound_nums = lbounds
112 ubound_nums = ubounds
113 else
114 lbound_nums(1) = lbound( array, 1 )
115 ubound_nums(1) = ubound( array, 1 )
116 end if
117 size_str = '('
118 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
119 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
120 size_str = trim(size_str) // ')'
121 !-------------------------------------------------------------------
122 ! 最大値
123 ! Maximum value
124 !-------------------------------------------------------------------
125 max_value = maxval(array)
126 !-------------------------------------------------------------------
127 ! 最小値
128 ! Minimum value
129 !-------------------------------------------------------------------
130 min_value = minval(array)
131 !-------------------------------------------------------------------
132 ! 平均値
133 ! Average value
134 !-------------------------------------------------------------------
135 alldim_size = size(array)
136 avg_value = sum(array) / dble(alldim_size)
137 !-------------------------------------------------------------------
138 ! 標準偏差
139 ! Standard deviation
140 !-------------------------------------------------------------------
141 sd_value = 0.0d0
142 variance_value = 0.0d0
143 sd_str = ''
144 if ( present_and_true( sd ) ) then
145 if ( alldim_size > 1 ) then
146 if (allocated(array_packed)) then
147 deallocate(array_packed)
148 end if
149 allocate( array_packed(alldim_size) )
150 array_packed = array
151 do i = 1, alldim_size
152 variance_value = variance_value + &
153 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
154 end do
155 variance_value = variance_value / dble(alldim_size)
156 sd_value = sqrt( variance_value )
157 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
158 end if
159 end if
160 !-------------------------------------------------------------------
161 ! 印字
162 ! Print
163 !-------------------------------------------------------------------
164 call printf(out_unit, &
165 & indent_str(1:indent_len) // &
166 & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
167 & i = (/max_value, min_value/), d = (/avg_value/), &
168 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlineint2()

subroutine putlineint2 ( integer, dimension(:,:), intent(in) array,
integer, dimension(2), intent(in), optional lbounds,
integer, dimension(2), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 2-dimensional int array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array2-dimensional int array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 195 of file dcstringputline.f90.

196 use dc_types, only: dp, string, stdout
197 use dc_string, only: tochar, printf, cprintf
198 use dc_present, only: present_and_true
199 implicit none
200 integer, intent(in):: array(:,:)
201 integer, intent(in), optional:: lbounds(2)
202 integer, intent(in), optional:: ubounds(2)
203 integer, intent(in), optional:: unit
204 character(*), intent(in), optional:: indent
205 logical, intent(in), optional:: sd
206 integer:: out_unit
207 integer:: indent_len
208 character(STRING):: indent_str
209 integer:: i
210 integer:: alldim_size, lbound_nums(2), ubound_nums(2)
211 character(STRING):: size_str, sd_str
212 integer:: max_value, min_value
213 integer, allocatable:: array_packed(:)
214 real(DP) :: avg_value, variance_value, sd_value
215 continue
216 !-----------------------------------------------------------------
217 ! オプショナル引数のチェック
218 ! Check optional arguments
219 !-----------------------------------------------------------------
220 if ( present(unit) ) then
221 out_unit = unit
222 else
223 out_unit = stdout
224 end if
225 indent_len = 0
226 indent_str = ''
227 if ( present(indent) ) then
228 if (len(indent) /= 0) then
229 indent_len = len(indent)
230 indent_str(1:indent_len) = indent
231 end if
232 end if
233 !-------------------------------------------------------------------
234 ! 配列サイズ
235 ! Array size
236 !-------------------------------------------------------------------
237 if ( present(lbounds) .and. present(ubounds) ) then
238 lbound_nums = lbounds
239 ubound_nums = ubounds
240 else
241 lbound_nums(1) = lbound( array, 1 )
242 ubound_nums(1) = ubound( array, 1 )
243 lbound_nums(2) = lbound( array, 2 )
244 ubound_nums(2) = ubound( array, 2 )
245 end if
246 size_str = '('
247 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
248 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
249 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
250 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
251 size_str = trim(size_str) // ')'
252 !-------------------------------------------------------------------
253 ! 最大値
254 ! Maximum value
255 !-------------------------------------------------------------------
256 max_value = maxval(array)
257 !-------------------------------------------------------------------
258 ! 最小値
259 ! Minimum value
260 !-------------------------------------------------------------------
261 min_value = minval(array)
262 !-------------------------------------------------------------------
263 ! 平均値
264 ! Average value
265 !-------------------------------------------------------------------
266 alldim_size = size(array)
267 avg_value = sum(array) / dble(alldim_size)
268 !-------------------------------------------------------------------
269 ! 標準偏差
270 ! Standard deviation
271 !-------------------------------------------------------------------
272 sd_value = 0.0d0
273 variance_value = 0.0d0
274 sd_str = ''
275 if ( present_and_true( sd ) ) then
276 if ( alldim_size > 1 ) then
277 if (allocated(array_packed)) then
278 deallocate(array_packed)
279 end if
280 allocate( array_packed(alldim_size) )
281 array_packed = pack(array, .true.)
282 do i = 1, alldim_size
283 variance_value = variance_value + &
284 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
285 end do
286 variance_value = variance_value / dble(alldim_size)
287 sd_value = sqrt( variance_value )
288 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
289 end if
290 end if
291 !-------------------------------------------------------------------
292 ! 印字
293 ! Print
294 !-------------------------------------------------------------------
295 call printf(out_unit, &
296 & indent_str(1:indent_len) // &
297 & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
298 & i = (/max_value, min_value/), d = (/avg_value/), &
299 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlineint3()

subroutine putlineint3 ( integer, dimension(:,:,:), intent(in) array,
integer, dimension(3), intent(in), optional lbounds,
integer, dimension(3), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 3-dimensional int array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array3-dimensional int array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 326 of file dcstringputline.f90.

327 use dc_types, only: dp, string, stdout
328 use dc_string, only: tochar, printf, cprintf
329 use dc_present, only: present_and_true
330 implicit none
331 integer, intent(in):: array(:,:,:)
332 integer, intent(in), optional:: lbounds(3)
333 integer, intent(in), optional:: ubounds(3)
334 integer, intent(in), optional:: unit
335 character(*), intent(in), optional:: indent
336 logical, intent(in), optional:: sd
337 integer:: out_unit
338 integer:: indent_len
339 character(STRING):: indent_str
340 integer:: i
341 integer:: alldim_size, lbound_nums(3), ubound_nums(3)
342 character(STRING):: size_str, sd_str
343 integer:: max_value, min_value
344 integer, allocatable:: array_packed(:)
345 real(DP) :: avg_value, variance_value, sd_value
346 continue
347 !-----------------------------------------------------------------
348 ! オプショナル引数のチェック
349 ! Check optional arguments
350 !-----------------------------------------------------------------
351 if ( present(unit) ) then
352 out_unit = unit
353 else
354 out_unit = stdout
355 end if
356 indent_len = 0
357 indent_str = ''
358 if ( present(indent) ) then
359 if (len(indent) /= 0) then
360 indent_len = len(indent)
361 indent_str(1:indent_len) = indent
362 end if
363 end if
364 !-------------------------------------------------------------------
365 ! 配列サイズ
366 ! Array size
367 !-------------------------------------------------------------------
368 if ( present(lbounds) .and. present(ubounds) ) then
369 lbound_nums = lbounds
370 ubound_nums = ubounds
371 else
372 lbound_nums(1) = lbound( array, 1 )
373 ubound_nums(1) = ubound( array, 1 )
374 lbound_nums(2) = lbound( array, 2 )
375 ubound_nums(2) = ubound( array, 2 )
376 lbound_nums(3) = lbound( array, 3 )
377 ubound_nums(3) = ubound( array, 3 )
378 end if
379 size_str = '('
380 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
381 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
382 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
383 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
384 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
385 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
386 size_str = trim(size_str) // ')'
387 !-------------------------------------------------------------------
388 ! 最大値
389 ! Maximum value
390 !-------------------------------------------------------------------
391 max_value = maxval(array)
392 !-------------------------------------------------------------------
393 ! 最小値
394 ! Minimum value
395 !-------------------------------------------------------------------
396 min_value = minval(array)
397 !-------------------------------------------------------------------
398 ! 平均値
399 ! Average value
400 !-------------------------------------------------------------------
401 alldim_size = size(array)
402 avg_value = sum(array) / dble(alldim_size)
403 !-------------------------------------------------------------------
404 ! 標準偏差
405 ! Standard deviation
406 !-------------------------------------------------------------------
407 sd_value = 0.0d0
408 variance_value = 0.0d0
409 sd_str = ''
410 if ( present_and_true( sd ) ) then
411 if ( alldim_size > 1 ) then
412 if (allocated(array_packed)) then
413 deallocate(array_packed)
414 end if
415 allocate( array_packed(alldim_size) )
416 array_packed = pack(array, .true.)
417 do i = 1, alldim_size
418 variance_value = variance_value + &
419 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
420 end do
421 variance_value = variance_value / dble(alldim_size)
422 sd_value = sqrt( variance_value )
423 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
424 end if
425 end if
426 !-------------------------------------------------------------------
427 ! 印字
428 ! Print
429 !-------------------------------------------------------------------
430 call printf(out_unit, &
431 & indent_str(1:indent_len) // &
432 & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
433 & i = (/max_value, min_value/), d = (/avg_value/), &
434 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlineint4()

subroutine putlineint4 ( integer, dimension(:,:,:,:), intent(in) array,
integer, dimension(4), intent(in), optional lbounds,
integer, dimension(4), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 4-dimensional int array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array4-dimensional int array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 461 of file dcstringputline.f90.

462 use dc_types, only: dp, string, stdout
463 use dc_string, only: tochar, printf, cprintf
464 use dc_present, only: present_and_true
465 implicit none
466 integer, intent(in):: array(:,:,:,:)
467 integer, intent(in), optional:: lbounds(4)
468 integer, intent(in), optional:: ubounds(4)
469 integer, intent(in), optional:: unit
470 character(*), intent(in), optional:: indent
471 logical, intent(in), optional:: sd
472 integer:: out_unit
473 integer:: indent_len
474 character(STRING):: indent_str
475 integer:: i
476 integer:: alldim_size, lbound_nums(4), ubound_nums(4)
477 character(STRING):: size_str, sd_str
478 integer:: max_value, min_value
479 integer, allocatable:: array_packed(:)
480 real(DP) :: avg_value, variance_value, sd_value
481 continue
482 !-----------------------------------------------------------------
483 ! オプショナル引数のチェック
484 ! Check optional arguments
485 !-----------------------------------------------------------------
486 if ( present(unit) ) then
487 out_unit = unit
488 else
489 out_unit = stdout
490 end if
491 indent_len = 0
492 indent_str = ''
493 if ( present(indent) ) then
494 if (len(indent) /= 0) then
495 indent_len = len(indent)
496 indent_str(1:indent_len) = indent
497 end if
498 end if
499 !-------------------------------------------------------------------
500 ! 配列サイズ
501 ! Array size
502 !-------------------------------------------------------------------
503 if ( present(lbounds) .and. present(ubounds) ) then
504 lbound_nums = lbounds
505 ubound_nums = ubounds
506 else
507 lbound_nums(1) = lbound( array, 1 )
508 ubound_nums(1) = ubound( array, 1 )
509 lbound_nums(2) = lbound( array, 2 )
510 ubound_nums(2) = ubound( array, 2 )
511 lbound_nums(3) = lbound( array, 3 )
512 ubound_nums(3) = ubound( array, 3 )
513 lbound_nums(4) = lbound( array, 4 )
514 ubound_nums(4) = ubound( array, 4 )
515 end if
516 size_str = '('
517 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
518 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
519 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
520 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
521 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
522 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
523 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
524 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
525 size_str = trim(size_str) // ')'
526 !-------------------------------------------------------------------
527 ! 最大値
528 ! Maximum value
529 !-------------------------------------------------------------------
530 max_value = maxval(array)
531 !-------------------------------------------------------------------
532 ! 最小値
533 ! Minimum value
534 !-------------------------------------------------------------------
535 min_value = minval(array)
536 !-------------------------------------------------------------------
537 ! 平均値
538 ! Average value
539 !-------------------------------------------------------------------
540 alldim_size = size(array)
541 avg_value = sum(array) / dble(alldim_size)
542 !-------------------------------------------------------------------
543 ! 標準偏差
544 ! Standard deviation
545 !-------------------------------------------------------------------
546 sd_value = 0.0d0
547 variance_value = 0.0d0
548 sd_str = ''
549 if ( present_and_true( sd ) ) then
550 if ( alldim_size > 1 ) then
551 if (allocated(array_packed)) then
552 deallocate(array_packed)
553 end if
554 allocate( array_packed(alldim_size) )
555 array_packed = pack(array, .true.)
556 do i = 1, alldim_size
557 variance_value = variance_value + &
558 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
559 end do
560 variance_value = variance_value / dble(alldim_size)
561 sd_value = sqrt( variance_value )
562 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
563 end if
564 end if
565 !-------------------------------------------------------------------
566 ! 印字
567 ! Print
568 !-------------------------------------------------------------------
569 call printf(out_unit, &
570 & indent_str(1:indent_len) // &
571 & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
572 & i = (/max_value, min_value/), d = (/avg_value/), &
573 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlineint5()

subroutine putlineint5 ( integer, dimension(:,:,:,:,:), intent(in) array,
integer, dimension(5), intent(in), optional lbounds,
integer, dimension(5), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 5-dimensional int array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array5-dimensional int array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 600 of file dcstringputline.f90.

601 use dc_types, only: dp, string, stdout
602 use dc_string, only: tochar, printf, cprintf
603 use dc_present, only: present_and_true
604 implicit none
605 integer, intent(in):: array(:,:,:,:,:)
606 integer, intent(in), optional:: lbounds(5)
607 integer, intent(in), optional:: ubounds(5)
608 integer, intent(in), optional:: unit
609 character(*), intent(in), optional:: indent
610 logical, intent(in), optional:: sd
611 integer:: out_unit
612 integer:: indent_len
613 character(STRING):: indent_str
614 integer:: i
615 integer:: alldim_size, lbound_nums(5), ubound_nums(5)
616 character(STRING):: size_str, sd_str
617 integer:: max_value, min_value
618 integer, allocatable:: array_packed(:)
619 real(DP) :: avg_value, variance_value, sd_value
620 continue
621 !-----------------------------------------------------------------
622 ! オプショナル引数のチェック
623 ! Check optional arguments
624 !-----------------------------------------------------------------
625 if ( present(unit) ) then
626 out_unit = unit
627 else
628 out_unit = stdout
629 end if
630 indent_len = 0
631 indent_str = ''
632 if ( present(indent) ) then
633 if (len(indent) /= 0) then
634 indent_len = len(indent)
635 indent_str(1:indent_len) = indent
636 end if
637 end if
638 !-------------------------------------------------------------------
639 ! 配列サイズ
640 ! Array size
641 !-------------------------------------------------------------------
642 if ( present(lbounds) .and. present(ubounds) ) then
643 lbound_nums = lbounds
644 ubound_nums = ubounds
645 else
646 lbound_nums(1) = lbound( array, 1 )
647 ubound_nums(1) = ubound( array, 1 )
648 lbound_nums(2) = lbound( array, 2 )
649 ubound_nums(2) = ubound( array, 2 )
650 lbound_nums(3) = lbound( array, 3 )
651 ubound_nums(3) = ubound( array, 3 )
652 lbound_nums(4) = lbound( array, 4 )
653 ubound_nums(4) = ubound( array, 4 )
654 lbound_nums(5) = lbound( array, 5 )
655 ubound_nums(5) = ubound( array, 5 )
656 end if
657 size_str = '('
658 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
659 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
660 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
661 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
662 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
663 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
664 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
665 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
666 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
667 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
668 size_str = trim(size_str) // ')'
669 !-------------------------------------------------------------------
670 ! 最大値
671 ! Maximum value
672 !-------------------------------------------------------------------
673 max_value = maxval(array)
674 !-------------------------------------------------------------------
675 ! 最小値
676 ! Minimum value
677 !-------------------------------------------------------------------
678 min_value = minval(array)
679 !-------------------------------------------------------------------
680 ! 平均値
681 ! Average value
682 !-------------------------------------------------------------------
683 alldim_size = size(array)
684 avg_value = sum(array) / dble(alldim_size)
685 !-------------------------------------------------------------------
686 ! 標準偏差
687 ! Standard deviation
688 !-------------------------------------------------------------------
689 sd_value = 0.0d0
690 variance_value = 0.0d0
691 sd_str = ''
692 if ( present_and_true( sd ) ) then
693 if ( alldim_size > 1 ) then
694 if (allocated(array_packed)) then
695 deallocate(array_packed)
696 end if
697 allocate( array_packed(alldim_size) )
698 array_packed = pack(array, .true.)
699 do i = 1, alldim_size
700 variance_value = variance_value + &
701 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
702 end do
703 variance_value = variance_value / dble(alldim_size)
704 sd_value = sqrt( variance_value )
705 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
706 end if
707 end if
708 !-------------------------------------------------------------------
709 ! 印字
710 ! Print
711 !-------------------------------------------------------------------
712 call printf(out_unit, &
713 & indent_str(1:indent_len) // &
714 & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
715 & i = (/max_value, min_value/), d = (/avg_value/), &
716 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlineint6()

subroutine putlineint6 ( integer, dimension(:,:,:,:,:,:), intent(in) array,
integer, dimension(6), intent(in), optional lbounds,
integer, dimension(6), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 6-dimensional int array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array6-dimensional int array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 743 of file dcstringputline.f90.

744 use dc_types, only: dp, string, stdout
745 use dc_string, only: tochar, printf, cprintf
746 use dc_present, only: present_and_true
747 implicit none
748 integer, intent(in):: array(:,:,:,:,:,:)
749 integer, intent(in), optional:: lbounds(6)
750 integer, intent(in), optional:: ubounds(6)
751 integer, intent(in), optional:: unit
752 character(*), intent(in), optional:: indent
753 logical, intent(in), optional:: sd
754 integer:: out_unit
755 integer:: indent_len
756 character(STRING):: indent_str
757 integer:: i
758 integer:: alldim_size, lbound_nums(6), ubound_nums(6)
759 character(STRING):: size_str, sd_str
760 integer:: max_value, min_value
761 integer, allocatable:: array_packed(:)
762 real(DP) :: avg_value, variance_value, sd_value
763 continue
764 !-----------------------------------------------------------------
765 ! オプショナル引数のチェック
766 ! Check optional arguments
767 !-----------------------------------------------------------------
768 if ( present(unit) ) then
769 out_unit = unit
770 else
771 out_unit = stdout
772 end if
773 indent_len = 0
774 indent_str = ''
775 if ( present(indent) ) then
776 if (len(indent) /= 0) then
777 indent_len = len(indent)
778 indent_str(1:indent_len) = indent
779 end if
780 end if
781 !-------------------------------------------------------------------
782 ! 配列サイズ
783 ! Array size
784 !-------------------------------------------------------------------
785 if ( present(lbounds) .and. present(ubounds) ) then
786 lbound_nums = lbounds
787 ubound_nums = ubounds
788 else
789 lbound_nums(1) = lbound( array, 1 )
790 ubound_nums(1) = ubound( array, 1 )
791 lbound_nums(2) = lbound( array, 2 )
792 ubound_nums(2) = ubound( array, 2 )
793 lbound_nums(3) = lbound( array, 3 )
794 ubound_nums(3) = ubound( array, 3 )
795 lbound_nums(4) = lbound( array, 4 )
796 ubound_nums(4) = ubound( array, 4 )
797 lbound_nums(5) = lbound( array, 5 )
798 ubound_nums(5) = ubound( array, 5 )
799 lbound_nums(6) = lbound( array, 6 )
800 ubound_nums(6) = ubound( array, 6 )
801 end if
802 size_str = '('
803 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
804 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
805 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
806 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
807 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
808 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
809 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
810 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
811 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
812 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
813 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
814 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
815 size_str = trim(size_str) // ')'
816 !-------------------------------------------------------------------
817 ! 最大値
818 ! Maximum value
819 !-------------------------------------------------------------------
820 max_value = maxval(array)
821 !-------------------------------------------------------------------
822 ! 最小値
823 ! Minimum value
824 !-------------------------------------------------------------------
825 min_value = minval(array)
826 !-------------------------------------------------------------------
827 ! 平均値
828 ! Average value
829 !-------------------------------------------------------------------
830 alldim_size = size(array)
831 avg_value = sum(array) / dble(alldim_size)
832 !-------------------------------------------------------------------
833 ! 標準偏差
834 ! Standard deviation
835 !-------------------------------------------------------------------
836 sd_value = 0.0d0
837 variance_value = 0.0d0
838 sd_str = ''
839 if ( present_and_true( sd ) ) then
840 if ( alldim_size > 1 ) then
841 if (allocated(array_packed)) then
842 deallocate(array_packed)
843 end if
844 allocate( array_packed(alldim_size) )
845 array_packed = pack(array, .true.)
846 do i = 1, alldim_size
847 variance_value = variance_value + &
848 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
849 end do
850 variance_value = variance_value / dble(alldim_size)
851 sd_value = sqrt( variance_value )
852 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
853 end if
854 end if
855 !-------------------------------------------------------------------
856 ! 印字
857 ! Print
858 !-------------------------------------------------------------------
859 call printf(out_unit, &
860 & indent_str(1:indent_len) // &
861 & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
862 & i = (/max_value, min_value/), d = (/avg_value/), &
863 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlineint7()

subroutine putlineint7 ( integer, dimension(:,:,:,:,:,:,:), intent(in) array,
integer, dimension(7), intent(in), optional lbounds,
integer, dimension(7), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 7-dimensional int array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array7-dimensional int array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 890 of file dcstringputline.f90.

891 use dc_types, only: dp, string, stdout
892 use dc_string, only: tochar, printf, cprintf
893 use dc_present, only: present_and_true
894 implicit none
895 integer, intent(in):: array(:,:,:,:,:,:,:)
896 integer, intent(in), optional:: lbounds(7)
897 integer, intent(in), optional:: ubounds(7)
898 integer, intent(in), optional:: unit
899 character(*), intent(in), optional:: indent
900 logical, intent(in), optional:: sd
901 integer:: out_unit
902 integer:: indent_len
903 character(STRING):: indent_str
904 integer:: i
905 integer:: alldim_size, lbound_nums(7), ubound_nums(7)
906 character(STRING):: size_str, sd_str
907 integer:: max_value, min_value
908 integer, allocatable:: array_packed(:)
909 real(DP) :: avg_value, variance_value, sd_value
910 continue
911 !-----------------------------------------------------------------
912 ! オプショナル引数のチェック
913 ! Check optional arguments
914 !-----------------------------------------------------------------
915 if ( present(unit) ) then
916 out_unit = unit
917 else
918 out_unit = stdout
919 end if
920 indent_len = 0
921 indent_str = ''
922 if ( present(indent) ) then
923 if (len(indent) /= 0) then
924 indent_len = len(indent)
925 indent_str(1:indent_len) = indent
926 end if
927 end if
928 !-------------------------------------------------------------------
929 ! 配列サイズ
930 ! Array size
931 !-------------------------------------------------------------------
932 if ( present(lbounds) .and. present(ubounds) ) then
933 lbound_nums = lbounds
934 ubound_nums = ubounds
935 else
936 lbound_nums(1) = lbound( array, 1 )
937 ubound_nums(1) = ubound( array, 1 )
938 lbound_nums(2) = lbound( array, 2 )
939 ubound_nums(2) = ubound( array, 2 )
940 lbound_nums(3) = lbound( array, 3 )
941 ubound_nums(3) = ubound( array, 3 )
942 lbound_nums(4) = lbound( array, 4 )
943 ubound_nums(4) = ubound( array, 4 )
944 lbound_nums(5) = lbound( array, 5 )
945 ubound_nums(5) = ubound( array, 5 )
946 lbound_nums(6) = lbound( array, 6 )
947 ubound_nums(6) = ubound( array, 6 )
948 lbound_nums(7) = lbound( array, 7 )
949 ubound_nums(7) = ubound( array, 7 )
950 end if
951 size_str = '('
952 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
953 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
954 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
955 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
956 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
957 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
958 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
959 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
960 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
961 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
962 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
963 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
964 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(7)))
965 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(7)))
966 size_str = trim(size_str) // ')'
967 !-------------------------------------------------------------------
968 ! 最大値
969 ! Maximum value
970 !-------------------------------------------------------------------
971 max_value = maxval(array)
972 !-------------------------------------------------------------------
973 ! 最小値
974 ! Minimum value
975 !-------------------------------------------------------------------
976 min_value = minval(array)
977 !-------------------------------------------------------------------
978 ! 平均値
979 ! Average value
980 !-------------------------------------------------------------------
981 alldim_size = size(array)
982 avg_value = sum(array) / dble(alldim_size)
983 !-------------------------------------------------------------------
984 ! 標準偏差
985 ! Standard deviation
986 !-------------------------------------------------------------------
987 sd_value = 0.0d0
988 variance_value = 0.0d0
989 sd_str = ''
990 if ( present_and_true( sd ) ) then
991 if ( alldim_size > 1 ) then
992 if (allocated(array_packed)) then
993 deallocate(array_packed)
994 end if
995 allocate( array_packed(alldim_size) )
996 array_packed = pack(array, .true.)
997 do i = 1, alldim_size
998 variance_value = variance_value + &
999 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1000 end do
1001 variance_value = variance_value / dble(alldim_size)
1002 sd_value = sqrt( variance_value )
1003 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1004 end if
1005 end if
1006 !-------------------------------------------------------------------
1007 ! 印字
1008 ! Print
1009 !-------------------------------------------------------------------
1010 call printf(out_unit, &
1011 & indent_str(1:indent_len) // &
1012 & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
1013 & i = (/max_value, min_value/), d = (/avg_value/), &
1014 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinereal1()

subroutine putlinereal1 ( real(sp), dimension(:), intent(in) array,
integer, dimension(1), intent(in), optional lbounds,
integer, dimension(1), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 1-dimensional real array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array1-dimensional real array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 1041 of file dcstringputline.f90.

1042 use dc_types, only: dp, string, stdout,sp
1043 use dc_string, only: tochar, printf, cprintf
1044 use dc_present, only: present_and_true
1045 implicit none
1046 real(SP), intent(in):: array(:)
1047 integer, intent(in), optional:: lbounds(1)
1048 integer, intent(in), optional:: ubounds(1)
1049 integer, intent(in), optional:: unit
1050 character(*), intent(in), optional:: indent
1051 logical, intent(in), optional:: sd
1052 integer:: out_unit
1053 integer:: indent_len
1054 character(STRING):: indent_str
1055 integer:: i
1056 integer:: alldim_size, lbound_nums(1), ubound_nums(1)
1057 character(STRING):: size_str, sd_str
1058 real(SP) :: max_value, min_value
1059 real(SP), allocatable :: array_packed(:)
1060 real(DP) :: avg_value, variance_value, sd_value
1061 continue
1062 !-----------------------------------------------------------------
1063 ! オプショナル引数のチェック
1064 ! Check optional arguments
1065 !-----------------------------------------------------------------
1066 if ( present(unit) ) then
1067 out_unit = unit
1068 else
1069 out_unit = stdout
1070 end if
1071 indent_len = 0
1072 indent_str = ''
1073 if ( present(indent) ) then
1074 if (len(indent) /= 0) then
1075 indent_len = len(indent)
1076 indent_str(1:indent_len) = indent
1077 end if
1078 end if
1079 !-------------------------------------------------------------------
1080 ! 配列サイズ
1081 ! Array size
1082 !-------------------------------------------------------------------
1083 if ( present(lbounds) .and. present(ubounds) ) then
1084 lbound_nums = lbounds
1085 ubound_nums = ubounds
1086 else
1087 lbound_nums(1) = lbound( array, 1 )
1088 ubound_nums(1) = ubound( array, 1 )
1089 end if
1090 size_str = '('
1091 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
1092 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
1093 size_str = trim(size_str) // ')'
1094 !-------------------------------------------------------------------
1095 ! 最大値
1096 ! Maximum value
1097 !-------------------------------------------------------------------
1098 max_value = maxval(array)
1099 !-------------------------------------------------------------------
1100 ! 最小値
1101 ! Minimum value
1102 !-------------------------------------------------------------------
1103 min_value = minval(array)
1104 !-------------------------------------------------------------------
1105 ! 平均値
1106 ! Average value
1107 !-------------------------------------------------------------------
1108 alldim_size = size(array)
1109 avg_value = sum(array) / dble(alldim_size)
1110 !-------------------------------------------------------------------
1111 ! 標準偏差
1112 ! Standard deviation
1113 !-------------------------------------------------------------------
1114 sd_value = 0.0d0
1115 variance_value = 0.0d0
1116 sd_str = ''
1117 if ( present_and_true( sd ) ) then
1118 if ( alldim_size > 1 ) then
1119 if (allocated(array_packed)) then
1120 deallocate(array_packed)
1121 end if
1122 allocate( array_packed(alldim_size) )
1123 array_packed = array
1124 do i = 1, alldim_size
1125 variance_value = variance_value + &
1126 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1127 end do
1128 variance_value = variance_value / dble(alldim_size)
1129 sd_value = sqrt( variance_value )
1130 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1131 end if
1132 end if
1133 !-------------------------------------------------------------------
1134 ! 印字
1135 ! Print
1136 !-------------------------------------------------------------------
1137 call printf(out_unit, &
1138 & indent_str(1:indent_len) // &
1139 & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
1140 & r = (/max_value, min_value/), d = (/avg_value/), &
1141 & c1 = trim(size_str), c2 = trim(sd_str) )
dc_types::sp
integer, parameter, public sp
Single Precision Real number.
Definition dc_types.f90:82

References dc_types::dp, dc_present::present_and_true(), dc_types::sp, dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinereal2()

subroutine putlinereal2 ( real(sp), dimension(:,:), intent(in) array,
integer, dimension(2), intent(in), optional lbounds,
integer, dimension(2), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 2-dimensional real array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array2-dimensional real array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 1168 of file dcstringputline.f90.

1169 use dc_types, only: dp, string, stdout,sp
1170 use dc_string, only: tochar, printf, cprintf
1171 use dc_present, only: present_and_true
1172 implicit none
1173 real(SP), intent(in):: array(:,:)
1174 integer, intent(in), optional:: lbounds(2)
1175 integer, intent(in), optional:: ubounds(2)
1176 integer, intent(in), optional:: unit
1177 character(*), intent(in), optional:: indent
1178 logical, intent(in), optional:: sd
1179 integer:: out_unit
1180 integer:: indent_len
1181 character(STRING):: indent_str
1182 integer:: i
1183 integer:: alldim_size, lbound_nums(2), ubound_nums(2)
1184 character(STRING):: size_str, sd_str
1185 real(SP) :: max_value, min_value
1186 real(SP), allocatable :: array_packed(:)
1187 real(DP) :: avg_value, variance_value, sd_value
1188 continue
1189 !-----------------------------------------------------------------
1190 ! オプショナル引数のチェック
1191 ! Check optional arguments
1192 !-----------------------------------------------------------------
1193 if ( present(unit) ) then
1194 out_unit = unit
1195 else
1196 out_unit = stdout
1197 end if
1198 indent_len = 0
1199 indent_str = ''
1200 if ( present(indent) ) then
1201 if (len(indent) /= 0) then
1202 indent_len = len(indent)
1203 indent_str(1:indent_len) = indent
1204 end if
1205 end if
1206 !-------------------------------------------------------------------
1207 ! 配列サイズ
1208 ! Array size
1209 !-------------------------------------------------------------------
1210 if ( present(lbounds) .and. present(ubounds) ) then
1211 lbound_nums = lbounds
1212 ubound_nums = ubounds
1213 else
1214 lbound_nums(1) = lbound( array, 1 )
1215 ubound_nums(1) = ubound( array, 1 )
1216 lbound_nums(2) = lbound( array, 2 )
1217 ubound_nums(2) = ubound( array, 2 )
1218 end if
1219 size_str = '('
1220 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
1221 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
1222 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
1223 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
1224 size_str = trim(size_str) // ')'
1225 !-------------------------------------------------------------------
1226 ! 最大値
1227 ! Maximum value
1228 !-------------------------------------------------------------------
1229 max_value = maxval(array)
1230 !-------------------------------------------------------------------
1231 ! 最小値
1232 ! Minimum value
1233 !-------------------------------------------------------------------
1234 min_value = minval(array)
1235 !-------------------------------------------------------------------
1236 ! 平均値
1237 ! Average value
1238 !-------------------------------------------------------------------
1239 alldim_size = size(array)
1240 avg_value = sum(array) / dble(alldim_size)
1241 !-------------------------------------------------------------------
1242 ! 標準偏差
1243 ! Standard deviation
1244 !-------------------------------------------------------------------
1245 sd_value = 0.0d0
1246 variance_value = 0.0d0
1247 sd_str = ''
1248 if ( present_and_true( sd ) ) then
1249 if ( alldim_size > 1 ) then
1250 if (allocated(array_packed)) then
1251 deallocate(array_packed)
1252 end if
1253 allocate( array_packed(alldim_size) )
1254 array_packed = pack(array, .true.)
1255 do i = 1, alldim_size
1256 variance_value = variance_value + &
1257 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1258 end do
1259 variance_value = variance_value / dble(alldim_size)
1260 sd_value = sqrt( variance_value )
1261 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1262 end if
1263 end if
1264 !-------------------------------------------------------------------
1265 ! 印字
1266 ! Print
1267 !-------------------------------------------------------------------
1268 call printf(out_unit, &
1269 & indent_str(1:indent_len) // &
1270 & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
1271 & r = (/max_value, min_value/), d = (/avg_value/), &
1272 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::sp, dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinereal3()

subroutine putlinereal3 ( real(sp), dimension(:,:,:), intent(in) array,
integer, dimension(3), intent(in), optional lbounds,
integer, dimension(3), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 3-dimensional real array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array3-dimensional real array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 1299 of file dcstringputline.f90.

1300 use dc_types, only: dp, string, stdout,sp
1301 use dc_string, only: tochar, printf, cprintf
1302 use dc_present, only: present_and_true
1303 implicit none
1304 real(SP), intent(in):: array(:,:,:)
1305 integer, intent(in), optional:: lbounds(3)
1306 integer, intent(in), optional:: ubounds(3)
1307 integer, intent(in), optional:: unit
1308 character(*), intent(in), optional:: indent
1309 logical, intent(in), optional:: sd
1310 integer:: out_unit
1311 integer:: indent_len
1312 character(STRING):: indent_str
1313 integer:: i
1314 integer:: alldim_size, lbound_nums(3), ubound_nums(3)
1315 character(STRING):: size_str, sd_str
1316 real(SP) :: max_value, min_value
1317 real(SP), allocatable :: array_packed(:)
1318 real(DP) :: avg_value, variance_value, sd_value
1319 continue
1320 !-----------------------------------------------------------------
1321 ! オプショナル引数のチェック
1322 ! Check optional arguments
1323 !-----------------------------------------------------------------
1324 if ( present(unit) ) then
1325 out_unit = unit
1326 else
1327 out_unit = stdout
1328 end if
1329 indent_len = 0
1330 indent_str = ''
1331 if ( present(indent) ) then
1332 if (len(indent) /= 0) then
1333 indent_len = len(indent)
1334 indent_str(1:indent_len) = indent
1335 end if
1336 end if
1337 !-------------------------------------------------------------------
1338 ! 配列サイズ
1339 ! Array size
1340 !-------------------------------------------------------------------
1341 if ( present(lbounds) .and. present(ubounds) ) then
1342 lbound_nums = lbounds
1343 ubound_nums = ubounds
1344 else
1345 lbound_nums(1) = lbound( array, 1 )
1346 ubound_nums(1) = ubound( array, 1 )
1347 lbound_nums(2) = lbound( array, 2 )
1348 ubound_nums(2) = ubound( array, 2 )
1349 lbound_nums(3) = lbound( array, 3 )
1350 ubound_nums(3) = ubound( array, 3 )
1351 end if
1352 size_str = '('
1353 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
1354 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
1355 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
1356 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
1357 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
1358 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
1359 size_str = trim(size_str) // ')'
1360 !-------------------------------------------------------------------
1361 ! 最大値
1362 ! Maximum value
1363 !-------------------------------------------------------------------
1364 max_value = maxval(array)
1365 !-------------------------------------------------------------------
1366 ! 最小値
1367 ! Minimum value
1368 !-------------------------------------------------------------------
1369 min_value = minval(array)
1370 !-------------------------------------------------------------------
1371 ! 平均値
1372 ! Average value
1373 !-------------------------------------------------------------------
1374 alldim_size = size(array)
1375 avg_value = sum(array) / dble(alldim_size)
1376 !-------------------------------------------------------------------
1377 ! 標準偏差
1378 ! Standard deviation
1379 !-------------------------------------------------------------------
1380 sd_value = 0.0d0
1381 variance_value = 0.0d0
1382 sd_str = ''
1383 if ( present_and_true( sd ) ) then
1384 if ( alldim_size > 1 ) then
1385 if (allocated(array_packed)) then
1386 deallocate(array_packed)
1387 end if
1388 allocate( array_packed(alldim_size) )
1389 array_packed = pack(array, .true.)
1390 do i = 1, alldim_size
1391 variance_value = variance_value + &
1392 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1393 end do
1394 variance_value = variance_value / dble(alldim_size)
1395 sd_value = sqrt( variance_value )
1396 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1397 end if
1398 end if
1399 !-------------------------------------------------------------------
1400 ! 印字
1401 ! Print
1402 !-------------------------------------------------------------------
1403 call printf(out_unit, &
1404 & indent_str(1:indent_len) // &
1405 & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
1406 & r = (/max_value, min_value/), d = (/avg_value/), &
1407 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::sp, dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinereal4()

subroutine putlinereal4 ( real(sp), dimension(:,:,:,:), intent(in) array,
integer, dimension(4), intent(in), optional lbounds,
integer, dimension(4), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 4-dimensional real array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array4-dimensional real array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 1434 of file dcstringputline.f90.

1435 use dc_types, only: dp, string, stdout,sp
1436 use dc_string, only: tochar, printf, cprintf
1437 use dc_present, only: present_and_true
1438 implicit none
1439 real(SP), intent(in):: array(:,:,:,:)
1440 integer, intent(in), optional:: lbounds(4)
1441 integer, intent(in), optional:: ubounds(4)
1442 integer, intent(in), optional:: unit
1443 character(*), intent(in), optional:: indent
1444 logical, intent(in), optional:: sd
1445 integer:: out_unit
1446 integer:: indent_len
1447 character(STRING):: indent_str
1448 integer:: i
1449 integer:: alldim_size, lbound_nums(4), ubound_nums(4)
1450 character(STRING):: size_str, sd_str
1451 real(SP) :: max_value, min_value
1452 real(SP), allocatable :: array_packed(:)
1453 real(DP) :: avg_value, variance_value, sd_value
1454 continue
1455 !-----------------------------------------------------------------
1456 ! オプショナル引数のチェック
1457 ! Check optional arguments
1458 !-----------------------------------------------------------------
1459 if ( present(unit) ) then
1460 out_unit = unit
1461 else
1462 out_unit = stdout
1463 end if
1464 indent_len = 0
1465 indent_str = ''
1466 if ( present(indent) ) then
1467 if (len(indent) /= 0) then
1468 indent_len = len(indent)
1469 indent_str(1:indent_len) = indent
1470 end if
1471 end if
1472 !-------------------------------------------------------------------
1473 ! 配列サイズ
1474 ! Array size
1475 !-------------------------------------------------------------------
1476 if ( present(lbounds) .and. present(ubounds) ) then
1477 lbound_nums = lbounds
1478 ubound_nums = ubounds
1479 else
1480 lbound_nums(1) = lbound( array, 1 )
1481 ubound_nums(1) = ubound( array, 1 )
1482 lbound_nums(2) = lbound( array, 2 )
1483 ubound_nums(2) = ubound( array, 2 )
1484 lbound_nums(3) = lbound( array, 3 )
1485 ubound_nums(3) = ubound( array, 3 )
1486 lbound_nums(4) = lbound( array, 4 )
1487 ubound_nums(4) = ubound( array, 4 )
1488 end if
1489 size_str = '('
1490 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
1491 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
1492 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
1493 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
1494 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
1495 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
1496 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
1497 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
1498 size_str = trim(size_str) // ')'
1499 !-------------------------------------------------------------------
1500 ! 最大値
1501 ! Maximum value
1502 !-------------------------------------------------------------------
1503 max_value = maxval(array)
1504 !-------------------------------------------------------------------
1505 ! 最小値
1506 ! Minimum value
1507 !-------------------------------------------------------------------
1508 min_value = minval(array)
1509 !-------------------------------------------------------------------
1510 ! 平均値
1511 ! Average value
1512 !-------------------------------------------------------------------
1513 alldim_size = size(array)
1514 avg_value = sum(array) / dble(alldim_size)
1515 !-------------------------------------------------------------------
1516 ! 標準偏差
1517 ! Standard deviation
1518 !-------------------------------------------------------------------
1519 sd_value = 0.0d0
1520 variance_value = 0.0d0
1521 sd_str = ''
1522 if ( present_and_true( sd ) ) then
1523 if ( alldim_size > 1 ) then
1524 if (allocated(array_packed)) then
1525 deallocate(array_packed)
1526 end if
1527 allocate( array_packed(alldim_size) )
1528 array_packed = pack(array, .true.)
1529 do i = 1, alldim_size
1530 variance_value = variance_value + &
1531 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1532 end do
1533 variance_value = variance_value / dble(alldim_size)
1534 sd_value = sqrt( variance_value )
1535 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1536 end if
1537 end if
1538 !-------------------------------------------------------------------
1539 ! 印字
1540 ! Print
1541 !-------------------------------------------------------------------
1542 call printf(out_unit, &
1543 & indent_str(1:indent_len) // &
1544 & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
1545 & r = (/max_value, min_value/), d = (/avg_value/), &
1546 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::sp, dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinereal5()

subroutine putlinereal5 ( real(sp), dimension(:,:,:,:,:), intent(in) array,
integer, dimension(5), intent(in), optional lbounds,
integer, dimension(5), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 5-dimensional real array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array5-dimensional real array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 1573 of file dcstringputline.f90.

1574 use dc_types, only: dp, string, stdout,sp
1575 use dc_string, only: tochar, printf, cprintf
1576 use dc_present, only: present_and_true
1577 implicit none
1578 real(SP), intent(in):: array(:,:,:,:,:)
1579 integer, intent(in), optional:: lbounds(5)
1580 integer, intent(in), optional:: ubounds(5)
1581 integer, intent(in), optional:: unit
1582 character(*), intent(in), optional:: indent
1583 logical, intent(in), optional:: sd
1584 integer:: out_unit
1585 integer:: indent_len
1586 character(STRING):: indent_str
1587 integer:: i
1588 integer:: alldim_size, lbound_nums(5), ubound_nums(5)
1589 character(STRING):: size_str, sd_str
1590 real(SP) :: max_value, min_value
1591 real(SP), allocatable :: array_packed(:)
1592 real(DP) :: avg_value, variance_value, sd_value
1593 continue
1594 !-----------------------------------------------------------------
1595 ! オプショナル引数のチェック
1596 ! Check optional arguments
1597 !-----------------------------------------------------------------
1598 if ( present(unit) ) then
1599 out_unit = unit
1600 else
1601 out_unit = stdout
1602 end if
1603 indent_len = 0
1604 indent_str = ''
1605 if ( present(indent) ) then
1606 if (len(indent) /= 0) then
1607 indent_len = len(indent)
1608 indent_str(1:indent_len) = indent
1609 end if
1610 end if
1611 !-------------------------------------------------------------------
1612 ! 配列サイズ
1613 ! Array size
1614 !-------------------------------------------------------------------
1615 if ( present(lbounds) .and. present(ubounds) ) then
1616 lbound_nums = lbounds
1617 ubound_nums = ubounds
1618 else
1619 lbound_nums(1) = lbound( array, 1 )
1620 ubound_nums(1) = ubound( array, 1 )
1621 lbound_nums(2) = lbound( array, 2 )
1622 ubound_nums(2) = ubound( array, 2 )
1623 lbound_nums(3) = lbound( array, 3 )
1624 ubound_nums(3) = ubound( array, 3 )
1625 lbound_nums(4) = lbound( array, 4 )
1626 ubound_nums(4) = ubound( array, 4 )
1627 lbound_nums(5) = lbound( array, 5 )
1628 ubound_nums(5) = ubound( array, 5 )
1629 end if
1630 size_str = '('
1631 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
1632 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
1633 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
1634 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
1635 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
1636 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
1637 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
1638 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
1639 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
1640 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
1641 size_str = trim(size_str) // ')'
1642 !-------------------------------------------------------------------
1643 ! 最大値
1644 ! Maximum value
1645 !-------------------------------------------------------------------
1646 max_value = maxval(array)
1647 !-------------------------------------------------------------------
1648 ! 最小値
1649 ! Minimum value
1650 !-------------------------------------------------------------------
1651 min_value = minval(array)
1652 !-------------------------------------------------------------------
1653 ! 平均値
1654 ! Average value
1655 !-------------------------------------------------------------------
1656 alldim_size = size(array)
1657 avg_value = sum(array) / dble(alldim_size)
1658 !-------------------------------------------------------------------
1659 ! 標準偏差
1660 ! Standard deviation
1661 !-------------------------------------------------------------------
1662 sd_value = 0.0d0
1663 variance_value = 0.0d0
1664 sd_str = ''
1665 if ( present_and_true( sd ) ) then
1666 if ( alldim_size > 1 ) then
1667 if (allocated(array_packed)) then
1668 deallocate(array_packed)
1669 end if
1670 allocate( array_packed(alldim_size) )
1671 array_packed = pack(array, .true.)
1672 do i = 1, alldim_size
1673 variance_value = variance_value + &
1674 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1675 end do
1676 variance_value = variance_value / dble(alldim_size)
1677 sd_value = sqrt( variance_value )
1678 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1679 end if
1680 end if
1681 !-------------------------------------------------------------------
1682 ! 印字
1683 ! Print
1684 !-------------------------------------------------------------------
1685 call printf(out_unit, &
1686 & indent_str(1:indent_len) // &
1687 & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
1688 & r = (/max_value, min_value/), d = (/avg_value/), &
1689 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::sp, dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinereal6()

subroutine putlinereal6 ( real(sp), dimension(:,:,:,:,:,:), intent(in) array,
integer, dimension(6), intent(in), optional lbounds,
integer, dimension(6), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 6-dimensional real array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array6-dimensional real array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 1716 of file dcstringputline.f90.

1717 use dc_types, only: dp, string, stdout,sp
1718 use dc_string, only: tochar, printf, cprintf
1719 use dc_present, only: present_and_true
1720 implicit none
1721 real(SP), intent(in):: array(:,:,:,:,:,:)
1722 integer, intent(in), optional:: lbounds(6)
1723 integer, intent(in), optional:: ubounds(6)
1724 integer, intent(in), optional:: unit
1725 character(*), intent(in), optional:: indent
1726 logical, intent(in), optional:: sd
1727 integer:: out_unit
1728 integer:: indent_len
1729 character(STRING):: indent_str
1730 integer:: i
1731 integer:: alldim_size, lbound_nums(6), ubound_nums(6)
1732 character(STRING):: size_str, sd_str
1733 real(SP) :: max_value, min_value
1734 real(SP), allocatable :: array_packed(:)
1735 real(DP) :: avg_value, variance_value, sd_value
1736 continue
1737 !-----------------------------------------------------------------
1738 ! オプショナル引数のチェック
1739 ! Check optional arguments
1740 !-----------------------------------------------------------------
1741 if ( present(unit) ) then
1742 out_unit = unit
1743 else
1744 out_unit = stdout
1745 end if
1746 indent_len = 0
1747 indent_str = ''
1748 if ( present(indent) ) then
1749 if (len(indent) /= 0) then
1750 indent_len = len(indent)
1751 indent_str(1:indent_len) = indent
1752 end if
1753 end if
1754 !-------------------------------------------------------------------
1755 ! 配列サイズ
1756 ! Array size
1757 !-------------------------------------------------------------------
1758 if ( present(lbounds) .and. present(ubounds) ) then
1759 lbound_nums = lbounds
1760 ubound_nums = ubounds
1761 else
1762 lbound_nums(1) = lbound( array, 1 )
1763 ubound_nums(1) = ubound( array, 1 )
1764 lbound_nums(2) = lbound( array, 2 )
1765 ubound_nums(2) = ubound( array, 2 )
1766 lbound_nums(3) = lbound( array, 3 )
1767 ubound_nums(3) = ubound( array, 3 )
1768 lbound_nums(4) = lbound( array, 4 )
1769 ubound_nums(4) = ubound( array, 4 )
1770 lbound_nums(5) = lbound( array, 5 )
1771 ubound_nums(5) = ubound( array, 5 )
1772 lbound_nums(6) = lbound( array, 6 )
1773 ubound_nums(6) = ubound( array, 6 )
1774 end if
1775 size_str = '('
1776 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
1777 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
1778 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
1779 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
1780 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
1781 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
1782 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
1783 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
1784 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
1785 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
1786 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
1787 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
1788 size_str = trim(size_str) // ')'
1789 !-------------------------------------------------------------------
1790 ! 最大値
1791 ! Maximum value
1792 !-------------------------------------------------------------------
1793 max_value = maxval(array)
1794 !-------------------------------------------------------------------
1795 ! 最小値
1796 ! Minimum value
1797 !-------------------------------------------------------------------
1798 min_value = minval(array)
1799 !-------------------------------------------------------------------
1800 ! 平均値
1801 ! Average value
1802 !-------------------------------------------------------------------
1803 alldim_size = size(array)
1804 avg_value = sum(array) / dble(alldim_size)
1805 !-------------------------------------------------------------------
1806 ! 標準偏差
1807 ! Standard deviation
1808 !-------------------------------------------------------------------
1809 sd_value = 0.0d0
1810 variance_value = 0.0d0
1811 sd_str = ''
1812 if ( present_and_true( sd ) ) then
1813 if ( alldim_size > 1 ) then
1814 if (allocated(array_packed)) then
1815 deallocate(array_packed)
1816 end if
1817 allocate( array_packed(alldim_size) )
1818 array_packed = pack(array, .true.)
1819 do i = 1, alldim_size
1820 variance_value = variance_value + &
1821 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1822 end do
1823 variance_value = variance_value / dble(alldim_size)
1824 sd_value = sqrt( variance_value )
1825 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1826 end if
1827 end if
1828 !-------------------------------------------------------------------
1829 ! 印字
1830 ! Print
1831 !-------------------------------------------------------------------
1832 call printf(out_unit, &
1833 & indent_str(1:indent_len) // &
1834 & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
1835 & r = (/max_value, min_value/), d = (/avg_value/), &
1836 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::sp, dc_types::stdout, and dc_types::string.

Here is the call graph for this function:

◆ putlinereal7()

subroutine putlinereal7 ( real(sp), dimension(:,:,:,:,:,:,:), intent(in) array,
integer, dimension(7), intent(in), optional lbounds,
integer, dimension(7), intent(in), optional ubounds,
integer, intent(in), optional unit,
character(*), intent(in), optional indent,
logical, intent(in), optional sd )

Print summary of 7-dimensional real array

Prints array size, maximum, minimum, and average values. If sd is .true., also prints standard deviation.

Parameters
[in]array7-dimensional real array to summarize
[in]lboundsLower bounds of array dimensions (optional)
[in]uboundsUpper bounds of array dimensions (optional)
[in]unitOutput unit number (optional, default: STDOUT)
[in]indentIndentation string (optional)
[in]sdIf .true., print standard deviation (optional)

Definition at line 1863 of file dcstringputline.f90.

1864 use dc_types, only: dp, string, stdout,sp
1865 use dc_string, only: tochar, printf, cprintf
1866 use dc_present, only: present_and_true
1867 implicit none
1868 real(SP), intent(in):: array(:,:,:,:,:,:,:)
1869 integer, intent(in), optional:: lbounds(7)
1870 integer, intent(in), optional:: ubounds(7)
1871 integer, intent(in), optional:: unit
1872 character(*), intent(in), optional:: indent
1873 logical, intent(in), optional:: sd
1874 integer:: out_unit
1875 integer:: indent_len
1876 character(STRING):: indent_str
1877 integer:: i
1878 integer:: alldim_size, lbound_nums(7), ubound_nums(7)
1879 character(STRING):: size_str, sd_str
1880 real(SP) :: max_value, min_value
1881 real(SP), allocatable :: array_packed(:)
1882 real(DP) :: avg_value, variance_value, sd_value
1883 continue
1884 !-----------------------------------------------------------------
1885 ! オプショナル引数のチェック
1886 ! Check optional arguments
1887 !-----------------------------------------------------------------
1888 if ( present(unit) ) then
1889 out_unit = unit
1890 else
1891 out_unit = stdout
1892 end if
1893 indent_len = 0
1894 indent_str = ''
1895 if ( present(indent) ) then
1896 if (len(indent) /= 0) then
1897 indent_len = len(indent)
1898 indent_str(1:indent_len) = indent
1899 end if
1900 end if
1901 !-------------------------------------------------------------------
1902 ! 配列サイズ
1903 ! Array size
1904 !-------------------------------------------------------------------
1905 if ( present(lbounds) .and. present(ubounds) ) then
1906 lbound_nums = lbounds
1907 ubound_nums = ubounds
1908 else
1909 lbound_nums(1) = lbound( array, 1 )
1910 ubound_nums(1) = ubound( array, 1 )
1911 lbound_nums(2) = lbound( array, 2 )
1912 ubound_nums(2) = ubound( array, 2 )
1913 lbound_nums(3) = lbound( array, 3 )
1914 ubound_nums(3) = ubound( array, 3 )
1915 lbound_nums(4) = lbound( array, 4 )
1916 ubound_nums(4) = ubound( array, 4 )
1917 lbound_nums(5) = lbound( array, 5 )
1918 ubound_nums(5) = ubound( array, 5 )
1919 lbound_nums(6) = lbound( array, 6 )
1920 ubound_nums(6) = ubound( array, 6 )
1921 lbound_nums(7) = lbound( array, 7 )
1922 ubound_nums(7) = ubound( array, 7 )
1923 end if
1924 size_str = '('
1925 size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
1926 size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
1927 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
1928 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
1929 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
1930 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
1931 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
1932 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
1933 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
1934 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
1935 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
1936 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
1937 size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(7)))
1938 size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(7)))
1939 size_str = trim(size_str) // ')'
1940 !-------------------------------------------------------------------
1941 ! 最大値
1942 ! Maximum value
1943 !-------------------------------------------------------------------
1944 max_value = maxval(array)
1945 !-------------------------------------------------------------------
1946 ! 最小値
1947 ! Minimum value
1948 !-------------------------------------------------------------------
1949 min_value = minval(array)
1950 !-------------------------------------------------------------------
1951 ! 平均値
1952 ! Average value
1953 !-------------------------------------------------------------------
1954 alldim_size = size(array)
1955 avg_value = sum(array) / dble(alldim_size)
1956 !-------------------------------------------------------------------
1957 ! 標準偏差
1958 ! Standard deviation
1959 !-------------------------------------------------------------------
1960 sd_value = 0.0d0
1961 variance_value = 0.0d0
1962 sd_str = ''
1963 if ( present_and_true( sd ) ) then
1964 if ( alldim_size > 1 ) then
1965 if (allocated(array_packed)) then
1966 deallocate(array_packed)
1967 end if
1968 allocate( array_packed(alldim_size) )
1969 array_packed = pack(array, .true.)
1970 do i = 1, alldim_size
1971 variance_value = variance_value + &
1972 & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
1973 end do
1974 variance_value = variance_value / dble(alldim_size)
1975 sd_value = sqrt( variance_value )
1976 sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
1977 end if
1978 end if
1979 !-------------------------------------------------------------------
1980 ! 印字
1981 ! Print
1982 !-------------------------------------------------------------------
1983 call printf(out_unit, &
1984 & indent_str(1:indent_len) // &
1985 & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
1986 & r = (/max_value, min_value/), d = (/avg_value/), &
1987 & c1 = trim(size_str), c2 = trim(sd_str) )

References dc_types::dp, dc_present::present_and_true(), dc_types::sp, dc_types::stdout, and dc_types::string.

Here is the call graph for this function:
Generated on for gtool5 Fortran 90/95 Library by doxygen 1.15.0