oop - relacionales - sobrecarga de operador fortran(=)

sobrecarga del operador++

Question

¿Hay alguna forma de sobrecargar el operador = para que pueda escribir una tarea como en este ejemplo?

  module constants_mod
    integer,parameter :: dpn = selected_real_kind(14)
  end module

  module vectorField_mod
    use constants_mod
    implicit none
    private

    public :: vectorField
    public :: allocateX,allocateY,allocateZ
    public :: delete
    ! public :: operator(=)

    type vectorField
      integer,dimension(3) :: sx,sy,sz
      real(dpn),dimension(:,:,:),allocatable :: x,y,z
    end type

  interface delete
    module procedure deallocateVectorField
  end interface

  ! interface operator (=)
  !   module procedure vectorAssign
  ! end interface

  contains

    ! function vectorAssign(f) result(q)
    !   implicit none
    !   real(dpn),intent(in) :: f
    !   type(vectorField) :: q
    !   q%x = f; q%y = f; q%z = f
    ! end function

    ! subroutine vectorAssign(f,g)
    !   implicit none
    !   type(vectorField),intent(inout) :: f
    !   real(dpn),intent(in) :: g
    !   f%x = g; f%y = g; f%z = g
    ! end subroutine

    subroutine allocateX(field,Nx,Ny,Nz)
      implicit none
      type(vectorField),intent(inout) :: field
      integer,intent(in) :: Nx,Ny,Nz
      if (allocated(field%x)) deallocate(field%x)
      allocate(field%x(Nx,Ny,Nz))
      field%sx = shape(field%x)
    end subroutine

    subroutine allocateY(field,Nx,Ny,Nz)
      implicit none
      type(vectorField),intent(inout) :: field
      integer,intent(in) :: Nx,Ny,Nz
      if (allocated(field%y)) deallocate(field%y)
      allocate(field%y(Nx,Ny,Nz))
      field%sy = shape(field%y)
    end subroutine

    subroutine allocateZ(field,Nx,Ny,Nz)
      implicit none
      type(vectorField),intent(inout) :: field
      integer,intent(in) :: Nx,Ny,Nz
      if (allocated(field%z)) deallocate(field%z)
      allocate(field%z(Nx,Ny,Nz))
      field%sz = shape(field%z)
    end subroutine

    subroutine deallocateVectorField(field)
      implicit none
      type(vectorField),intent(inout) :: field
      deallocate(field%x,field%y,field%z)
      field%sx = 0; field%sy = 0; field%sz = 0
    end subroutine

  end module

  program test
  use constants_mod
  use vectorField_mod
  implicit none
  type(vectorField) :: a
  integer :: N = 1
  real(dpn) :: dt = 0.1
  call allocateX(a,N,N,N)
  call allocateY(a,N,N,N)
  call allocateZ(a,N,N,N)

  a%x = dble(1.0) ! want to avoid this
  a%y = dble(1.0) ! want to avoid this
  a%z = dble(1.0) ! want to avoid this

  a = real(1.0,dpn) ! want this instead (does not compile)

  call delete(a)

  end program

He intentado de dos maneras diferentes (que se muestran en los comentarios) pero recibo errores que dicen que hay un error de sintaxis en la especificación genérica (para publicitar el operador =). ¡Cualquier ayuda para hacer esto es muy apreciada!

Answer 1

Para el operator(=) asignación definido operator(=) no es correcto, pero la assignment(=) es: ver Fortran 2008 12.4.3.4.3. Entonces, en cambio, quieres los dos bultos

public :: assignment (=)

y

interface assignment (=)
  module procedure vectorAssign
end interface

Tenga en cuenta que la forma correcta de definir la asignación es mediante la subrutina tal como la tiene (aunque el asignatario podría tener la intent(out) lugar de la intent(inout) ).

Answer 2

Sí, puede sobrecargar el operador de asignación. La sintaxis y los requisitos son diferentes para el operador de asignación que para otros operadores porque la semántica es fundamentalmente diferente: todos los demás operadores calculan un nuevo valor basado en uno o dos argumentos, sin cambiar los argumentos, mientras que la asignación cambia el valor de la mano izquierda argumento.

En tu caso, creo que debería verse así:

module vectorField_mod

! ...

  interface assignment (=)
    module procedure vectorAssign
  end interface

contains

  ! ...

  subroutine vectorAssign(f,g)
    implicit none
    type(vectorField),intent(out) :: f
    real(kind = dpn), intent(in) :: g
    f%x = g
    f%y = g
    f%z = g
  end subroutine vectorAssign

end module vectorField_mod

Answer 3

= no es un operador, es una misión en Fortran y son bestias muy diferentes.

Para la posibilidad clásica encontrada en Fortran 90 y explicada bien en otras respuestas, Fortran 2003 agregó una mejor posibilidad de vincular los operadores y asignaciones sobrecargados con el tipo derivado.

De esta forma, está seguro de que no importará el tipo sin la asignación (¡tenga cuidado con las declaraciones públicas y privadas en este caso!). Puede tener consecuencias muy desagradables y puede ser difícil de depurar:

type vectorField
  integer,dimension(3) :: sx,sy,sz
  real(dpn),dimension(:,:,:),allocatable :: x,y,z
contains
  procedure :: assignVector
  generic :: assignment(=) => assignVector
end type

De esta forma no tienes que ser tan cuidadoso como para no olvidarte de la public :: assignment (=)