dcstringputline.f90

Go to the documentation of this file.

! -*- mode: f90; coding: utf-8 -*-
!-----------------------------------------------------------------------
! Copyright (c) 2000-2026 Gtool Development Group. All rights reserved.
!-----------------------------------------------------------------------
subroutine putlineint1( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlineint1
subroutine putlineint2( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlineint2
subroutine putlineint3( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlineint3
subroutine putlineint4( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlineint4
subroutine putlineint5( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlineint5
subroutine putlineint6( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlineint6
subroutine putlineint7( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlineint7
subroutine putlinereal1( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinereal1
subroutine putlinereal2( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinereal2
subroutine putlinereal3( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinereal3
subroutine putlinereal4( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinereal4
subroutine putlinereal5( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinereal5
subroutine putlinereal6( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinereal6
subroutine putlinereal7( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinereal7
subroutine putlinedouble1( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinedouble1
subroutine putlinedouble2( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinedouble2
subroutine putlinedouble3( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinedouble3
subroutine putlinedouble4( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinedouble4
subroutine putlinedouble5( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinedouble5
subroutine putlinedouble6( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinedouble6
subroutine putlinedouble7( array, lbounds, ubounds, unit, indent, sd )
  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) )
end subroutine putlinedouble7