Renamed files stdlib_bitset*.f90 to stdlib_bitset*.fypp

Renamed files stdlib_bitset*.f90 to fypp preprocessor stdlib_bitset*.fypp files [ticket: X]

src/stdlib_bitset_64.f90

@@ -82,7 +82,7 @@ pure module subroutine assign_64( set1, set2 )
  end subroutine assign_64
 
 
- module subroutine assign_log8_64( self, logical_vector )
+ module subroutine assign_logint8_64( self, logical_vector )
 ! Used to define assignment from an array of type logical for bitset_64
  type(bitset_64), intent(out) :: self
  logical(int8), intent(in) :: logical_vector(:)
@@ -104,38 +104,30 @@ module subroutine assign_log8_64( self, logical_vector )
  end if
  end do
 
- end subroutine assign_log8_64
+ end subroutine assign_logint8_64
 
 
- module subroutine assign_log16_64( self, logical_vector )
-! Used to define assignment from an array of type logical for bitset_64
- type(bitset_64), intent(out) :: self
- logical(int16), intent(in) :: logical_vector(:)
+ pure module subroutine logint8_assign_64( logical_vector, set )
+! Used to define assignment to an array of type logical for bitset_64
+ logical(int8), intent(out), allocatable :: logical_vector(:)
+ type(bitset_64), intent(in)  :: set
 
- integer(bits_kind) :: log_size
  integer(bits_kind) :: index
 
- log_size = size( logical_vector, kind=bits_kind )
- if ( log_size > 64 ) then
- error stop module_name // ' % ' // 'ASSIGNMENT' // " has " // &
- "SIZE(LOGICAL_VECTOR) > 64 with assignment to a BITSET_64."
- end if
- self % num_bits = log_size
- self % block = 0
-
- do index=0, log_size-1
- if ( logical_vector(index+1) ) then
- self % block = ibset( self % block, index )
+ allocate( logical_vector( set % num_bits ) )
+ do index=0, set % num_bits-1
+ if ( set % value( index ) == 1 ) then
+ logical_vector(index+1) = .true.
+ else
+ logical_vector(index+1) = .false.
  end if
  end do
 
- end subroutine assign_log16_64
-
-
- module subroutine assign_log32_64( self, logical_vector )
+ end subroutine logint8_assign_64
+ module subroutine assign_logint16_64( self, logical_vector )
 ! Used to define assignment from an array of type logical for bitset_64
  type(bitset_64), intent(out) :: self
- logical(int32), intent(in) :: logical_vector(:)
+ logical(int16), intent(in)  :: logical_vector(:)
 
  integer(bits_kind) :: log_size
  integer(bits_kind) :: index
@@ -154,13 +146,30 @@ module subroutine assign_log32_64( self, logical_vector )
  end if
  end do
 
- end subroutine assign_log32_64
+ end subroutine assign_logint16_64
+
+
+ pure module subroutine logint16_assign_64( logical_vector, set )
+! Used to define assignment to an array of type logical for bitset_64
+ logical(int16), intent(out), allocatable :: logical_vector(:)
+ type(bitset_64), intent(in) :: set
+
+ integer(bits_kind) :: index
 
+ allocate( logical_vector( set % num_bits ) )
+ do index=0, set % num_bits-1
+ if ( set % value( index ) == 1 ) then
+ logical_vector(index+1) = .true.
+ else
+ logical_vector(index+1) = .false.
+ end if
+ end do
 
- module subroutine assign_log64_64( self, logical_vector )
+ end subroutine logint16_assign_64
+ module subroutine assign_logint32_64( self, logical_vector )
 ! Used to define assignment from an array of type logical for bitset_64
  type(bitset_64), intent(out) :: self
- logical(int64), intent(in) :: logical_vector(:)
+ logical(int32), intent(in)  :: logical_vector(:)
 
  integer(bits_kind) :: log_size
  integer(bits_kind) :: index
@@ -179,12 +188,12 @@ module subroutine assign_log64_64( self, logical_vector )
  end if
  end do
 
- end subroutine assign_log64_64
+ end subroutine assign_logint32_64
 
 
- pure module subroutine log8_assign_64( logical_vector, set )
+ pure module subroutine logint32_assign_64( logical_vector, set )
 ! Used to define assignment to an array of type logical for bitset_64
- logical(int8), intent(out), allocatable :: logical_vector(:)
+ logical(int32), intent(out), allocatable :: logical_vector(:)
  type(bitset_64), intent(in) :: set
 
  integer(bits_kind) :: index
@@ -198,51 +207,36 @@ pure module subroutine log8_assign_64( logical_vector, set )
  end if
  end do
 
- end subroutine log8_assign_64
-
-
- pure module subroutine log16_assign_64( logical_vector, set )
-! Used to define assignment to an array of type logical for bitset_64
- logical(int16), intent(out), allocatable :: logical_vector(:)
- type(bitset_64), intent(in) :: set
+ end subroutine logint32_assign_64
+ module subroutine assign_logint64_64( self, logical_vector )
+! Used to define assignment from an array of type logical for bitset_64
+ type(bitset_64), intent(out) :: self
+ logical(int64), intent(in) :: logical_vector(:)
 
+ integer(bits_kind) :: log_size
  integer(bits_kind) :: index
 
- allocate( logical_vector( set % num_bits ) )
- do index=0, set % num_bits-1
- if ( set % value( index ) == 1 ) then
- logical_vector(index+1) = .true.
- else
- logical_vector(index+1) = .false.
- end if
- end do
-
- end subroutine log16_assign_64
-
-
- pure module subroutine log32_assign_64( logical_vector, set )
-! Used to define assignment to an array of type logical for bitset_64
- logical(int32), intent(out), allocatable :: logical_vector(:)
- type(bitset_64), intent(in) :: set
-
- integer(bits_kind) :: index
+ log_size = size( logical_vector, kind=bits_kind )
+ if ( log_size > 64 ) then
+ error stop module_name // ' % ' // 'ASSIGNMENT' // " has " // &
+ "SIZE(LOGICAL_VECTOR) > 64 with assignment to a BITSET_64."
+ end if
+ self % num_bits = log_size
+ self % block = 0
 
- allocate( logical_vector( set % num_bits ) )
- do index=0, set % num_bits-1
- if ( set % value( index ) == 1 ) then
- logical_vector(index+1) = .true.
- else
- logical_vector(index+1) = .false.
+ do index=0, log_size-1
+ if ( logical_vector(index+1) ) then
+ self % block = ibset( self % block, index )
  end if
  end do
 
- end subroutine log32_assign_64
+ end subroutine assign_logint64_64
 
 
- pure module subroutine log64_assign_64( logical_vector, set )
+ pure module subroutine logint64_assign_64( logical_vector, set )
 ! Used to define assignment to an array of type logical for bitset_64
  logical(int64), intent(out), allocatable :: logical_vector(:)
- type(bitset_64), intent(in)  :: set
+ type(bitset_64), intent(in) :: set
 
  integer(bits_kind) :: index
 
@@ -255,7 +249,7 @@ pure module subroutine log64_assign_64( logical_vector, set )
  end if
  end do
 
- end subroutine log64_assign_64
+ end subroutine logint64_assign_64
 
 
  elemental module function bit_count_64(self) result(bit_count)

src/stdlib_bitset_large.f90

@@ -99,8 +99,7 @@ pure module subroutine assign_large( set1, set2 )
 
  end subroutine assign_large
 
-
- pure module subroutine assign_log8_large( self, logical_vector )
+ pure module subroutine assign_logint8_large( self, logical_vector )
 ! Used to define assignment from an array of type logical for bitset_large
  type(bitset_large), intent(out) :: self
  logical(int8), intent(in) :: logical_vector(:)
@@ -125,41 +124,30 @@ pure module subroutine assign_log8_large( self, logical_vector )
  end if
  end do
 
- end subroutine assign_log8_large
+ end subroutine assign_logint8_large
 
 
- pure module subroutine assign_log16_large( self, logical_vector )
-! Used to define assignment from an array of type logical for bitset_large
- type(bitset_large), intent(out) :: self
- logical(int16), intent(in) :: logical_vector(:)
+ pure module subroutine logint8_assign_large( logical_vector, set )
+! Used to define assignment to an array of type logical for bitset_large
+ logical(int8), intent(out), allocatable :: logical_vector(:)
+ type(bitset_large), intent(in)  :: set
 
- integer(bits_kind) :: blocks
- integer(bits_kind) :: log_size
  integer(bits_kind) :: index
 
- log_size = size( logical_vector, kind=bits_kind )
- self % num_bits = log_size
- if ( log_size == 0 ) then
- blocks = 0
- else
- blocks = (log_size-1)/block_size + 1
- end if
- allocate( self % blocks( blocks ) )
- self % blocks(:) = 0
-
- do index=0, log_size-1
- if ( logical_vector(index+1) ) then
- call self % set( index )
+ allocate( logical_vector( set % num_bits ) )
+ do index=0, set % num_bits-1
+ if ( set % value( index ) == 1 ) then
+ logical_vector(index+1) = .true.
+ else
+ logical_vector(index+1) = .false.
  end if
  end do
 
- end subroutine assign_log16_large
-
-
- pure module subroutine assign_log32_large( self, logical_vector )
+ end subroutine logint8_assign_large
+ pure module subroutine assign_logint16_large( self, logical_vector )
 ! Used to define assignment from an array of type logical for bitset_large
  type(bitset_large), intent(out) :: self
- logical(int32), intent(in) :: logical_vector(:)
+ logical(int16), intent(in)  :: logical_vector(:)
 
  integer(bits_kind) :: blocks
  integer(bits_kind) :: log_size
@@ -181,13 +169,30 @@ pure module subroutine assign_log32_large( self, logical_vector )
  end if
  end do
 
- end subroutine assign_log32_large
+ end subroutine assign_logint16_large
+
+
+ pure module subroutine logint16_assign_large( logical_vector, set )
+! Used to define assignment to an array of type logical for bitset_large
+ logical(int16), intent(out), allocatable :: logical_vector(:)
+ type(bitset_large), intent(in) :: set
+
+ integer(bits_kind) :: index
 
+ allocate( logical_vector( set % num_bits ) )
+ do index=0, set % num_bits-1
+ if ( set % value( index ) == 1 ) then
+ logical_vector(index+1) = .true.
+ else
+ logical_vector(index+1) = .false.
+ end if
+ end do
 
- pure module subroutine assign_log64_large( self, logical_vector )
+ end subroutine logint16_assign_large
+ pure module subroutine assign_logint32_large( self, logical_vector )
 ! Used to define assignment from an array of type logical for bitset_large
  type(bitset_large), intent(out) :: self
- logical(int64), intent(in) :: logical_vector(:)
+ logical(int32), intent(in)  :: logical_vector(:)
 
  integer(bits_kind) :: blocks
  integer(bits_kind) :: log_size
@@ -209,12 +214,12 @@ pure module subroutine assign_log64_large( self, logical_vector )
  end if
  end do
 
- end subroutine assign_log64_large
+ end subroutine assign_logint32_large
 
 
- pure module subroutine log8_assign_large( logical_vector, set )
+ pure module subroutine logint32_assign_large( logical_vector, set )
 ! Used to define assignment to an array of type logical for bitset_large
- logical(int8), intent(out), allocatable :: logical_vector(:)
+ logical(int32), intent(out), allocatable :: logical_vector(:)
  type(bitset_large), intent(in) :: set
 
  integer(bits_kind) :: index
@@ -228,51 +233,39 @@ pure module subroutine log8_assign_large( logical_vector, set )
  end if
  end do
 
- end subroutine log8_assign_large
-
-
- pure module subroutine log16_assign_large( logical_vector, set )
-! Used to define assignment to an array of type logical for bitset_large
- logical(int16), intent(out), allocatable :: logical_vector(:)
- type(bitset_large), intent(in) :: set
+ end subroutine logint32_assign_large
+ pure module subroutine assign_logint64_large( self, logical_vector )
+! Used to define assignment from an array of type logical for bitset_large
+ type(bitset_large), intent(out) :: self
+ logical(int64), intent(in) :: logical_vector(:)
 
+ integer(bits_kind) :: blocks
+ integer(bits_kind) :: log_size
  integer(bits_kind) :: index
 
- allocate( logical_vector( set % num_bits ) )
- do index=0, set % num_bits-1
- if ( set % value( index ) == 1 ) then
- logical_vector(index+1) = .true.
- else
- logical_vector(index+1) = .false.
- end if
- end do
-
- end subroutine log16_assign_large
-
-
- pure module subroutine log32_assign_large( logical_vector, set )
-! Used to define assignment to an array of type logical for bitset_large
- logical(int32), intent(out), allocatable :: logical_vector(:)
- type(bitset_large), intent(in) :: set
-
- integer(bits_kind) :: index
+ log_size = size( logical_vector, kind=bits_kind )
+ self % num_bits = log_size
+ if ( log_size == 0 ) then
+ blocks = 0
+ else
+ blocks = (log_size-1)/block_size + 1
+ end if
+ allocate( self % blocks( blocks ) )
+ self % blocks(:) = 0
 
- allocate( logical_vector( set % num_bits ) )
- do index=0, set % num_bits-1
- if ( set % value( index ) == 1 ) then
- logical_vector(index+1) = .true.
- else
- logical_vector(index+1) = .false.
+ do index=0, log_size-1
+ if ( logical_vector(index+1) ) then
+ call self % set( index )
  end if
  end do
 
- end subroutine log32_assign_large
+ end subroutine assign_logint64_large
 
 
- pure module subroutine log64_assign_large( logical_vector, set )
+ pure module subroutine logint64_assign_large( logical_vector, set )
 ! Used to define assignment to an array of type logical for bitset_large
  logical(int64), intent(out), allocatable :: logical_vector(:)
- type(bitset_large), intent(in)  :: set
+ type(bitset_large), intent(in) :: set
 
  integer(bits_kind) :: index
 
@@ -285,7 +278,7 @@ pure module subroutine log64_assign_large( logical_vector, set )
  end if
  end do
 
- end subroutine log64_assign_large
+ end subroutine logint64_assign_large
 
 
  elemental module function bit_count_large(self) result(bit_count)