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]	array	1-dimensional double array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 2014 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(DP), intent(in):: array(:)
  integer, intent(in), optional:: lbounds(1)
  integer, intent(in), optional:: ubounds(1)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(1), ubound_nums(1)
  character(STRING):: size_str, sd_str
  real(DP) :: max_value, min_value
  real(DP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = array
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
    & d = (/max_value, min_value, avg_value/), &
    & 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:

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]	array	2-dimensional double array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 2141 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(DP), intent(in):: array(:,:)
  integer, intent(in), optional:: lbounds(2)
  integer, intent(in), optional:: ubounds(2)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(2), ubound_nums(2)
  character(STRING):: size_str, sd_str
  real(DP) :: max_value, min_value
  real(DP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
    & d = (/max_value, min_value, avg_value/), &
    & 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]	array	3-dimensional double array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 2272 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(DP), intent(in):: array(:,:,:)
  integer, intent(in), optional:: lbounds(3)
  integer, intent(in), optional:: ubounds(3)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(3), ubound_nums(3)
  character(STRING):: size_str, sd_str
  real(DP) :: max_value, min_value
  real(DP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
    & d = (/max_value, min_value, avg_value/), &
    & 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]	array	4-dimensional double array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 2407 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(DP), intent(in):: array(:,:,:,:)
  integer, intent(in), optional:: lbounds(4)
  integer, intent(in), optional:: ubounds(4)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(4), ubound_nums(4)
  character(STRING):: size_str, sd_str
  real(DP) :: max_value, min_value
  real(DP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
    & d = (/max_value, min_value, avg_value/), &
    & 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]	array	5-dimensional double array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 2546 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(DP), intent(in):: array(:,:,:,:,:)
  integer, intent(in), optional:: lbounds(5)
  integer, intent(in), optional:: ubounds(5)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(5), ubound_nums(5)
  character(STRING):: size_str, sd_str
  real(DP) :: max_value, min_value
  real(DP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
    & d = (/max_value, min_value, avg_value/), &
    & 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]	array	6-dimensional double array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 2689 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(DP), intent(in):: array(:,:,:,:,:,:)
  integer, intent(in), optional:: lbounds(6)
  integer, intent(in), optional:: ubounds(6)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(6), ubound_nums(6)
  character(STRING):: size_str, sd_str
  real(DP) :: max_value, min_value
  real(DP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
    lbound_nums(6) = lbound( array, 6 )
    ubound_nums(6) = ubound( array, 6 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
    & d = (/max_value, min_value, avg_value/), &
    & 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]	array	7-dimensional double array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 2836 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(DP), intent(in):: array(:,:,:,:,:,:,:)
  integer, intent(in), optional:: lbounds(7)
  integer, intent(in), optional:: ubounds(7)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(7), ubound_nums(7)
  character(STRING):: size_str, sd_str
  real(DP) :: max_value, min_value
  real(DP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
    lbound_nums(6) = lbound( array, 6 )
    ubound_nums(6) = ubound( array, 6 )
    lbound_nums(7) = lbound( array, 7 )
    ubound_nums(7) = ubound( array, 7 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(7)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(7)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<DP-ARRAY:: @size=%c, @max=%f, @min=%f, @avg=%f%c>', &
    & d = (/max_value, min_value, avg_value/), &
    & 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.

Definition at line 68 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  integer, intent(in):: array(:)
  integer, intent(in), optional:: lbounds(1)
  integer, intent(in), optional:: ubounds(1)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(1), ubound_nums(1)
  character(STRING):: size_str, sd_str
  integer:: max_value, min_value
  integer, allocatable:: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = array
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
    & i = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	2-dimensional int array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 195 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  integer, intent(in):: array(:,:)
  integer, intent(in), optional:: lbounds(2)
  integer, intent(in), optional:: ubounds(2)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(2), ubound_nums(2)
  character(STRING):: size_str, sd_str
  integer:: max_value, min_value
  integer, allocatable:: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
    & i = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	3-dimensional int array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 326 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  integer, intent(in):: array(:,:,:)
  integer, intent(in), optional:: lbounds(3)
  integer, intent(in), optional:: ubounds(3)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(3), ubound_nums(3)
  character(STRING):: size_str, sd_str
  integer:: max_value, min_value
  integer, allocatable:: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
    & i = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	4-dimensional int array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 461 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  integer, intent(in):: array(:,:,:,:)
  integer, intent(in), optional:: lbounds(4)
  integer, intent(in), optional:: ubounds(4)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(4), ubound_nums(4)
  character(STRING):: size_str, sd_str
  integer:: max_value, min_value
  integer, allocatable:: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
    & i = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	5-dimensional int array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 600 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  integer, intent(in):: array(:,:,:,:,:)
  integer, intent(in), optional:: lbounds(5)
  integer, intent(in), optional:: ubounds(5)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(5), ubound_nums(5)
  character(STRING):: size_str, sd_str
  integer:: max_value, min_value
  integer, allocatable:: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
    & i = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	6-dimensional int array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 743 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  integer, intent(in):: array(:,:,:,:,:,:)
  integer, intent(in), optional:: lbounds(6)
  integer, intent(in), optional:: ubounds(6)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(6), ubound_nums(6)
  character(STRING):: size_str, sd_str
  integer:: max_value, min_value
  integer, allocatable:: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
    lbound_nums(6) = lbound( array, 6 )
    ubound_nums(6) = ubound( array, 6 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
    & i = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	7-dimensional int array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 890 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  integer, intent(in):: array(:,:,:,:,:,:,:)
  integer, intent(in), optional:: lbounds(7)
  integer, intent(in), optional:: ubounds(7)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(7), ubound_nums(7)
  character(STRING):: size_str, sd_str
  integer:: max_value, min_value
  integer, allocatable:: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
    lbound_nums(6) = lbound( array, 6 )
    ubound_nums(6) = ubound( array, 6 )
    lbound_nums(7) = lbound( array, 7 )
    ubound_nums(7) = ubound( array, 7 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(7)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(7)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<INT-ARRAY:: @size=%c, @max=%d, @min=%d, @avg=%f%c>', &
    & i = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	1-dimensional real array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 1041 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout,sp
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(SP), intent(in):: array(:)
  integer, intent(in), optional:: lbounds(1)
  integer, intent(in), optional:: ubounds(1)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(1), ubound_nums(1)
  character(STRING):: size_str, sd_str
  real(SP) :: max_value, min_value
  real(SP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = array
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
    & r = (/max_value, min_value/), d = (/avg_value/), &
    & 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:

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]	array	2-dimensional real array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 1168 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout,sp
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(SP), intent(in):: array(:,:)
  integer, intent(in), optional:: lbounds(2)
  integer, intent(in), optional:: ubounds(2)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(2), ubound_nums(2)
  character(STRING):: size_str, sd_str
  real(SP) :: max_value, min_value
  real(SP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
    & r = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	3-dimensional real array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 1299 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout,sp
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(SP), intent(in):: array(:,:,:)
  integer, intent(in), optional:: lbounds(3)
  integer, intent(in), optional:: ubounds(3)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(3), ubound_nums(3)
  character(STRING):: size_str, sd_str
  real(SP) :: max_value, min_value
  real(SP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
    & r = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	4-dimensional real array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 1434 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout,sp
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(SP), intent(in):: array(:,:,:,:)
  integer, intent(in), optional:: lbounds(4)
  integer, intent(in), optional:: ubounds(4)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(4), ubound_nums(4)
  character(STRING):: size_str, sd_str
  real(SP) :: max_value, min_value
  real(SP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
    & r = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	5-dimensional real array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 1573 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout,sp
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(SP), intent(in):: array(:,:,:,:,:)
  integer, intent(in), optional:: lbounds(5)
  integer, intent(in), optional:: ubounds(5)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(5), ubound_nums(5)
  character(STRING):: size_str, sd_str
  real(SP) :: max_value, min_value
  real(SP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
    & r = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	6-dimensional real array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 1716 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout,sp
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(SP), intent(in):: array(:,:,:,:,:,:)
  integer, intent(in), optional:: lbounds(6)
  integer, intent(in), optional:: ubounds(6)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(6), ubound_nums(6)
  character(STRING):: size_str, sd_str
  real(SP) :: max_value, min_value
  real(SP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
    lbound_nums(6) = lbound( array, 6 )
    ubound_nums(6) = ubound( array, 6 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
    & r = (/max_value, min_value/), d = (/avg_value/), &
    & 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]	array	7-dimensional real array to summarize
[in]	lbounds	Lower bounds of array dimensions (optional)
[in]	ubounds	Upper bounds of array dimensions (optional)
[in]	unit	Output unit number (optional, default: STDOUT)
[in]	indent	Indentation string (optional)
[in]	sd	If .true., print standard deviation (optional)

Definition at line 1863 of file dcstringputline.f90.

  use dc_types, only: dp, string, stdout,sp
  use dc_string, only: tochar, printf, cprintf
  use dc_present, only: present_and_true
  implicit none
  real(SP), intent(in):: array(:,:,:,:,:,:,:)
  integer, intent(in), optional:: lbounds(7)
  integer, intent(in), optional:: ubounds(7)
  integer, intent(in), optional:: unit
  character(*), intent(in), optional:: indent
  logical, intent(in), optional:: sd
  integer:: out_unit
  integer:: indent_len
  character(STRING):: indent_str
  integer:: i
  integer:: alldim_size, lbound_nums(7), ubound_nums(7)
  character(STRING):: size_str, sd_str
  real(SP) :: max_value, min_value
  real(SP), allocatable :: array_packed(:)
  real(DP) :: avg_value, variance_value, sd_value
  continue
  !-----------------------------------------------------------------
  !  オプショナル引数のチェック
  !  Check optional arguments
  !-----------------------------------------------------------------
  if ( present(unit) ) then
    out_unit = unit
  else
    out_unit = stdout
  end if
  indent_len = 0
  indent_str = ''
  if ( present(indent) ) then
    if (len(indent) /= 0) then
      indent_len = len(indent)
      indent_str(1:indent_len) = indent
    end if
  end if
  !-------------------------------------------------------------------
  !  配列サイズ
  !  Array size
  !-------------------------------------------------------------------
  if ( present(lbounds) .and. present(ubounds) ) then
    lbound_nums = lbounds
    ubound_nums = ubounds
  else
    lbound_nums(1) = lbound( array, 1 )
    ubound_nums(1) = ubound( array, 1 )
    lbound_nums(2) = lbound( array, 2 )
    ubound_nums(2) = ubound( array, 2 )
    lbound_nums(3) = lbound( array, 3 )
    ubound_nums(3) = ubound( array, 3 )
    lbound_nums(4) = lbound( array, 4 )
    ubound_nums(4) = ubound( array, 4 )
    lbound_nums(5) = lbound( array, 5 )
    ubound_nums(5) = ubound( array, 5 )
    lbound_nums(6) = lbound( array, 6 )
    ubound_nums(6) = ubound( array, 6 )
    lbound_nums(7) = lbound( array, 7 )
    ubound_nums(7) = ubound( array, 7 )
  end if
  size_str = '('
  size_str = trim(size_str) // trim(tochar(lbound_nums(1))) // ':'
  size_str = trim(size_str) // trim(tochar(ubound_nums(1)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(2)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(2)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(3)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(3)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(4)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(4)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(5)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(5)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(6)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(6)))
  size_str = trim(size_str) // ',' // trim(tochar(lbound_nums(7)))
  size_str = trim(size_str) // ':' // trim(tochar(ubound_nums(7)))
  size_str = trim(size_str) // ')'
  !-------------------------------------------------------------------
  !  最大値
  !  Maximum value
  !-------------------------------------------------------------------
  max_value = maxval(array)
  !-------------------------------------------------------------------
  !  最小値
  !  Minimum value
  !-------------------------------------------------------------------
  min_value = minval(array)
  !-------------------------------------------------------------------
  !  平均値
  !  Average value
  !-------------------------------------------------------------------
  alldim_size = size(array)
  avg_value = sum(array) / dble(alldim_size)
  !-------------------------------------------------------------------
  !  標準偏差
  !  Standard deviation
  !-------------------------------------------------------------------
  sd_value = 0.0d0
  variance_value = 0.0d0
  sd_str = ''
  if ( present_and_true( sd ) ) then
    if ( alldim_size > 1 ) then
      if (allocated(array_packed)) then
        deallocate(array_packed)
      end if
      allocate( array_packed(alldim_size) )
      array_packed = pack(array, .true.)
      do i = 1, alldim_size
        variance_value = variance_value + &
          & (array_packed(i) - avg_value) * (array_packed(i) - avg_value)
      end do
      variance_value = variance_value / dble(alldim_size)
      sd_value = sqrt( variance_value )
      sd_str = cprintf( ' @sd=%f', d = (/ sd_value /) )
    end if
  end if
  !-------------------------------------------------------------------
  !  印字
  !  Print
  !-------------------------------------------------------------------
  call printf(out_unit, &
    & indent_str(1:indent_len) // &
    & '#<SP-ARRAY:: @size=%c, @max=%r, @min=%r, @avg=%f%c>', &
    & r = (/max_value, min_value/), d = (/avg_value/), &
    & 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: