tuple.f90

Go to the documentation of this file.

! Copyright (c) 2020-2023, The Neko Authors
! All rights reserved.
!
! Redistribution and use in source and binary forms, with or without
! modification, are permitted provided that the following conditions
! are met:
!
!   * Redistributions of source code must retain the above copyright
!     notice, this list of conditions and the following disclaimer.
!
!   * Redistributions in binary form must reproduce the above
!     copyright notice, this list of conditions and the following
!     disclaimer in the documentation and/or other materials provided
!     with the distribution.
!
!   * Neither the name of the authors nor the names of its
!     contributors may be used to endorse or promote products derived
!     from this software without specific prior written permission.
!
! THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
! "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
! LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
! FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
! COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
! INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
! BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
! LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
! CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
! LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
! ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
! POSSIBILITY OF SUCH DAMAGE.
!
module tuple
  use math, only : abscmp
  use num_types, only : dp
  implicit none
  private
 
  type, public, abstract :: tuple_t
   contains
     procedure(tuple_assign_tuple), pass(this), deferred :: assign_tuple
     procedure(tuple_assign_vector), pass(this), deferred :: assign_vector
     procedure(tuple_equal), pass(this) , deferred :: equal
     generic :: operator(.eq.) => equal
     generic :: assignment(=) => assign_tuple, assign_vector
  end type tuple_t
 
  type, public, extends(tuple_t) :: tuple_i4_t
     integer :: x(2) = (/0, 0/)
   contains
     procedure, pass(this) :: assign_tuple => tuple_i4_assign_tuple
     procedure, pass(this) :: assign_vector => tuple_i4_assign_vector
     procedure, pass(this) :: equal => tuple_i4_equal
  end type tuple_i4_t
 
  type, public, extends(tuple_t) :: tuple3_i4_t
     integer :: x(3) = (/0, 0, 0/)
   contains
     procedure, pass(this) :: assign_tuple => tuple3_i4_assign_tuple
     procedure, pass(this) :: assign_vector => tuple3_i4_assign_vector
     procedure, pass(this) :: equal => tuple3_i4_equal
  end type tuple3_i4_t
 
  type, public, extends(tuple_t) :: tuple4_i4_t
     integer :: x(4) = (/0, 0, 0, 0/)
   contains
     procedure, pass(this) :: assign_tuple => tuple4_i4_assign_tuple
     procedure, pass(this) :: assign_vector => tuple4_i4_assign_vector
     procedure, pass(this) :: equal => tuple4_i4_equal
  end type tuple4_i4_t
 
  type, public, extends(tuple_t) :: tuple_r8_t
     real(kind=dp) :: x(2) = (/0d0, 0d0/)
   contains
     procedure, pass(this) :: assign_tuple => tuple_r8_assign_tuple
     procedure, pass(this) :: assign_vector => tuple_r8_assign_vector
     procedure, pass(this) :: equal => tuple_r8_equal
  end type tuple_r8_t
 
  type, public, extends(tuple_t) :: tuple_i4r8_t
     integer :: x
     real(kind=dp) :: y
   contains
     procedure, pass(this) :: assign_tuple => tuple_i4r8_assign_tuple
     procedure, pass(this) :: assign_vector => tuple_i4r8_assign_vector
     procedure, pass(this) :: equal => tuple_i4r8_equal
  end type tuple_i4r8_t
 
  type, public, extends(tuple_t) :: tuple_2i4r8_t
     integer :: x, y
     real(kind=dp) :: z
   contains
     procedure, pass(this) :: assign_tuple => tuple_2i4r8_assign_tuple
     procedure, pass(this) :: assign_vector => tuple_2i4r8_assign_vector
     procedure, pass(this) :: equal => tuple_2i4r8_equal
  end type tuple_2i4r8_t
 
  abstract interface
     subroutine tuple_assign_tuple(this, other)
       import :: tuple_t
       class(tuple_t), intent(inout) :: this
       class(tuple_t), intent(in) :: other
     end subroutine tuple_assign_tuple
  end interface
 
  abstract interface
     subroutine tuple_assign_vector(this, x)
       import :: tuple_t
       class(tuple_t), intent(inout) :: this
       class(*), dimension(:), intent(in) :: x
     end subroutine tuple_assign_vector
  end interface
 
  abstract interface
     pure function tuple_equal(this, other) result(res)
       import :: tuple_t
       class(tuple_t), intent(in) :: this
       class(tuple_t), intent(in) :: other
       logical :: res
     end function tuple_equal
  end interface
 
contains
 
  subroutine tuple_i4_assign_tuple(this, other)
    class(tuple_i4_t), intent(inout) :: this
    class(tuple_t), intent(in) :: other
 
    select type(other)
    type is (tuple_i4_t)
       this%x = other%x
    end select
  end subroutine tuple_i4_assign_tuple
 
  subroutine tuple_i4_assign_vector(this, x)
    class(tuple_i4_t), intent(inout) :: this
    class(*), dimension(:), intent(in) :: x
 
    select type(x)
    type is (integer)
       this%x = x
    end select
  end subroutine tuple_i4_assign_vector
 
  pure function tuple_i4_equal(this, other) result(res)
    class(tuple_i4_t), intent(in) :: this
    class(tuple_t), intent(in) :: other
    logical :: res
 
    res = .false.
    select type(other)
    type is(tuple_i4_t)
       res = all(this%x .eq. other%x)
    end select
  end function tuple_i4_equal
 
  subroutine tuple3_i4_assign_tuple(this, other)
    class(tuple3_i4_t), intent(inout) :: this
    class(tuple_t), intent(in) :: other
 
    select type(other)
    type is(tuple3_i4_t)
       this%x = other%x
    end select
  end subroutine tuple3_i4_assign_tuple
 
  subroutine tuple3_i4_assign_vector(this, x)
    class(tuple3_i4_t), intent(inout) :: this
    class(*), dimension(:), intent(in) :: x
 
    select type(x)
    type is (integer)
       this%x = x
    end select
  end subroutine tuple3_i4_assign_vector
 
  pure function tuple3_i4_equal(this, other) result(res)
    class(tuple3_i4_t), intent(in) :: this
    class(tuple_t), intent(in) :: other
    logical :: res
 
    res = .false.
    select type(other)
    type is(tuple3_i4_t)
       res = all(this%x .eq. other%x)
    end select
  end function tuple3_i4_equal
 
  subroutine tuple4_i4_assign_tuple(this, other)
    class(tuple4_i4_t), intent(inout) :: this
    class(tuple_t), intent(in) :: other
 
    select type(other)
    type is(tuple4_i4_t)
       this%x = other%x
    end select
  end subroutine tuple4_i4_assign_tuple
 
  subroutine tuple4_i4_assign_vector(this, x)
    class(tuple4_i4_t), intent(inout) :: this
    class(*), dimension(:), intent(in) :: x
 
    select type(x)
    type is (integer)
       this%x = x
    end select
  end subroutine tuple4_i4_assign_vector
 
  pure function tuple4_i4_equal(this, other) result(res)
    class(tuple4_i4_t), intent(in) :: this
    class(tuple_t), intent(in) :: other
    logical :: res
 
    res = .false.
    select type(other)
    type is(tuple4_i4_t)
       res = all(this%x .eq. other%x)
    end select
  end function tuple4_i4_equal
 
  subroutine tuple_r8_assign_tuple(this, other)
    class(tuple_r8_t), intent(inout) :: this
    class(tuple_t), intent(in) :: other
 
    select type(other)
    type is(tuple_r8_t)
       this%x = other%x
    end select
  end subroutine tuple_r8_assign_tuple
 
  subroutine tuple_r8_assign_vector(this, x)
    class(tuple_r8_t), intent(inout) :: this
    class(*), dimension(:), intent(in) :: x
 
    select type(x)
    type is (double precision)
       this%x = x
    end select
  end subroutine tuple_r8_assign_vector
 
  pure function tuple_r8_equal(this, other) result(res)
    class(tuple_r8_t), intent(in) :: this
    class(tuple_t), intent(in) :: other
    logical :: res
 
    res = .false.
    select type(other)
    type is(tuple_r8_t)
       if (abscmp(this%x(1), other%x(1)) .and. &
            abscmp(this%x(2), other%x(2))) then
          res = .true.
       end if
    end select
  end function tuple_r8_equal
 
  subroutine tuple_i4r8_assign_tuple(this, other)
    class(tuple_i4r8_t), intent(inout) :: this
    class(tuple_t), intent(in) :: other
 
    select type(other)
    type is(tuple_i4r8_t)
       this%x = other%x
       this%y = other%y
    end select
  end subroutine tuple_i4r8_assign_tuple
 
  subroutine tuple_i4r8_assign_vector(this, x)
    class(tuple_i4r8_t), intent(inout) :: this
    class(*), dimension(:), intent(in) :: x
 
    select type(x)
    type is (integer)
       this%x = x(1)
       this%y = dble(x(2))
    type is (double precision)
       this%x = int(x(1))
       this%y = x(2)
    end select
 
  end subroutine tuple_i4r8_assign_vector
 
  pure function tuple_i4r8_equal(this, other) result(res)
    class(tuple_i4r8_t), intent(in) :: this
    class(tuple_t), intent(in) :: other
    logical :: res
 
    res = .false.
    select type(other)
    type is(tuple_i4r8_t)
       if ((this%x .eq. other%x) .and. &
            abscmp(this%y, other%y)) then
          res = .true.
       end if
    end select
  end function tuple_i4r8_equal
 
  subroutine tuple_2i4r8_assign_tuple(this, other)
    class(tuple_2i4r8_t), intent(inout) :: this
    class(tuple_t), intent(in) :: other
 
    select type(other)
    type is(tuple_2i4r8_t)
       this%x = other%x
       this%y = other%y
       this%z = other%z
    end select
  end subroutine tuple_2i4r8_assign_tuple
 
  subroutine tuple_2i4r8_assign_vector(this, x)
    class(tuple_2i4r8_t), intent(inout) :: this
    class(*), dimension(:), intent(in) :: x
 
    select type(x)
    type is (integer)
       this%x = x(1)
       this%y = x(2)
       this%z = dble(x(3))
    type is (double precision)
       this%x = int(x(1))
       this%y = int(x(2))
       this%z = x(3)
    end select
 
  end subroutine tuple_2i4r8_assign_vector
 
  pure function tuple_2i4r8_equal(this, other) result(res)
    class(tuple_2i4r8_t), intent(in) :: this
    class(tuple_t), intent(in) :: other
    logical :: res
 
    res = .false.
    select type(other)
    type is(tuple_2i4r8_t)
       if ((this%x .eq. other%x) .and. &
            (this%y .eq. other%y) .and. &
            abscmp(this%z, other%z)) then
          res = .true.
       end if
    end select
  end function tuple_2i4r8_equal
 
end module tuple