Traits ve Fortranu

[Idris]

ja bych si furt myslel, ze na numericke pocitani ol'good fortran a jeste mpi na cluster.

Pro paralelní zpracování (HPC clustery) má pěkná rozšíření Fortran 2018.

[Reklama]

[mikrom]

Tak s tymi Quaternionmi to samozrejme vo Fortrane ide.
Nadefinujes si vlastny typ Queternion a k nemu overloadujes operatory + - *
To sa urobi zase cez moduly , ziadne traity nie su treba.

[mikrom]

Napriklad, takto to funguje s tymi quaternionmi:

quaternions.f95

Kód: [Vybrat]

module my_quaternions
  type quaternion
    real :: x, y, z, t
  end type quaternion

  interface assignment(=)
    module procedure quaternion_from_array
  end interface

  interface operator(+)
    module procedure add_quaternions
  end interface 

  interface operator(-)
    module procedure substract_quaternions
  end interface

  interface operator(*)
    module procedure hamilton_product
  end interface 

contains
  subroutine quaternion_from_array(q, v)
    ! construct quaternion Q from an array V
    ! Q = V
    real, dimension(4), intent(in) :: v
    type(quaternion), intent(out) :: q
    q%x = v(1)
    q%y = v(2)
    q%z = v(3)
    q%t = v(4)
  end subroutine quaternion_from_array

  subroutine print_quaternion(q, q_name)
    type(quaternion), intent(in) :: q
    character(*), intent(in) :: q_name
    write (*, 10) q_name,' = (', q%x, ', ', q%y, ', ', q%z, ', ', q%t, ')'
    write (*,*)
    10 format(a, a, f8.2, a, f8.2, a, f8.2, a, f8.2, a)
  end subroutine print_quaternion

  function add_quaternions(a, b) result(c)
    type(quaternion), intent(in) :: a
    type(quaternion), intent(in) :: b
    type(quaternion) :: c
    c%x = a%x + b%x
    c%y = a%y + b%y
    c%z = a%z + b%z
    c%t = a%t + b%t
  end function add_quaternions

  function substract_quaternions(a, b) result(c)
    type(quaternion), intent(in) :: a, b
    type(quaternion) :: c
    c%x = a%x - b%x
    c%y = a%y - b%y
    c%z = a%z - b%z
    c%t = a%t - b%t
  end function substract_quaternions

  function hamilton_product(a, b) result(c)
    type(quaternion), intent(in) :: a, b
    type(quaternion) :: c
    c%x = a%x*b%x - a%y*b%y - a%z*b%z - a%t*b%t
    c%y = a%x*b%y + a%y*b%x + a%z*b%t - a%t*b%z
    c%z = a%x*b%z - a%y*b%t + a%z*b%x - a%t*b%y
    c%t = a%x*b%t + a%y*b%z - a%z*b%y + a%t*b%x
  end function hamilton_product

end module my_quaternions

program quaternions
  use my_quaternions
  type(quaternion) :: a, b, c

  write (*,'(a)') 'Quaternions example:'
  b = (/1., 2., 3., 4./)
  a = (/5., 6., 7., 8./)
  call print_quaternion(a, 'a')
  call print_quaternion(b, 'b')

  write (*,'(a)') 'c = a + b'
  c = a + b
  call print_quaternion(c, 'c')
 
  write (*,'(a)') 'c = a - b'
  c = a - b
  call print_quaternion(c, 'c')

  write (*,'(a)') 'c = a * b'
  c = a * b
  call print_quaternion(c, 'c')
end program quaternions

Output:

Kód: [Vybrat]

$ gfortran quaternions.f95 -o quaternions
$ ./quaternions
Quaternions example:
a = (    5.00,     6.00,     7.00,     8.00)

b = (    1.00,     2.00,     3.00,     4.00)

c = a + b
c = (    6.00,     8.00,    10.00,    12.00)

c = a - b
c = (    4.00,     4.00,     4.00,     4.00)

c = a * b
c = (  -60.00,    20.00,   -18.00,    32.00)


[mikrom]

ja bych si furt myslel, ze na numericke pocitani ol'good fortran a jeste mpi na cluster.

Pro paralelní zpracování (HPC clustery) má pěkná rozšíření Fortran 2018.

a jak vies ze tie rozsirenia su pekne, ked si povedal ze vo fortrane neprogramujes    btw. ja som asi iba raz v zivote experimentalne pouzil OpenMP

[Idris]

Tak s tymi Quaternionmi to samozrejme vo Fortrane ide.

 

[Reklama]

[Idris]

a jak vies ze tie rozsirenia su pekne, ked si povedal ze vo fortrane neprogramujes

To jsem nikdy neřekl, jen že nepoužívám GNU Fortran a nepotřebuju v něm OOP, to je docela rozdíl.

[Idris]

něco jako rustí std::io::Read nebo io.Reader (Go)

K tomuto jsem zapomněl dodat, že zrovna pro read/write Fortran plnohodnotné “traity” má.

[mikrom]

Este som tie kvaterniony trochu zmenil, teraz nepouzivam overloading assignemt operatora = aby som naplnil kvaternion z pola
a = (/1., 2., 3., 4./)
ale vytvaram ho à la OOP takto:
a = Quaternion(1., 2., 3., 4.)
Takze modul mi sluzi ako class pre kvaternion, dodal som tam aj metodu print ktora sa pouzica tymto sposobom
a%print

quaternions_class.f95

Kód: [Vybrat]

module my_quaternions
  type :: Quaternion
    real :: x, y, z, t
    contains
      procedure :: print => print_quaternion
  end type quaternion

  interface operator(+)
    module procedure add_quaternions
  end interface

  interface operator(-)
    module procedure substract_quaternions
  end interface

  interface operator(*)
    module procedure hamilton_product
  end interface 

contains
  subroutine print_quaternion(this)
    class(Quaternion), intent(in) :: this
    write (*, 10) '(', this%x, ', ', this%y, ', ', this%z, ', ', this%t, ')'
    write (*,*)
    10 format(a, f8.2, a, f8.2, a, f8.2, a, f8.2, a)
  end subroutine print_quaternion

  function add_quaternions(a, b) result(c)
    type(Quaternion), intent(in) :: a
    type(Quaternion), intent(in) :: b
    type(quaternion) :: c
    c%x = a%x + b%x
    c%y = a%y + b%y
    c%z = a%z + b%z
    c%t = a%t + b%t
  end function add_quaternions
 
  function substract_quaternions(a, b) result(c)
    type(quaternion), intent(in) :: a, b
    type(quaternion) :: c
    c%x = a%x - b%x
    c%y = a%y - b%y
    c%z = a%z - b%z
    c%t = a%t - b%t
  end function substract_quaternions

  function hamilton_product(a, b) result(c)
    type(quaternion), intent(in) :: a, b
    type(quaternion) :: c
    c%x = a%x*b%x - a%y*b%y - a%z*b%z - a%t*b%t
    c%y = a%x*b%y + a%y*b%x + a%z*b%t - a%t*b%z
    c%z = a%x*b%z - a%y*b%t + a%z*b%x - a%t*b%y
    c%t = a%x*b%t + a%y*b%z - a%z*b%y + a%t*b%x
  end function hamilton_product

end module my_quaternions

program quaternions
  use my_quaternions
   
  type(Quaternion) :: a, b, c
  b = Quaternion(1., 2., 3., 4.)
  a = Quaternion(5., 6., 7., 8.)
  write(*, '(a)', advance="no") 'a = '
  call a%print()
  write(*, '(a)', advance="no") 'b = '
  call b%print()
 
  write (*,'(a)') 'c = a + b'
  c = a + b
  write(*, '(a)', advance="no") 'c = '
  call c%print

  write (*,'(a)') 'c = a - b'
  c = a - b
  call c%print

  write (*,'(a)') 'c = a * b'
  c = a * b
  call c%print
end program quaternions

Output:

Kód: [Vybrat]

$ gfortran quaternions_class.f95 -o quaternions_class
$ ./quaternions_class
a = (    5.00,     6.00,     7.00,     8.00)

b = (    1.00,     2.00,     3.00,     4.00)

c = a + b
c = (    6.00,     8.00,    10.00,    12.00)

c = a - b
(    4.00,     4.00,     4.00,     4.00)

c = a * b
(  -60.00,    20.00,   -18.00,    32.00)


[mikrom]

... viz co psal Ink. Moduly jsou jen jmenné prostory ...

Never nikomu, kym si to sam neoveris. Nie su to len name spaces - nainstaluj si gfortran a pozri si moj predosly priklad quaternions_class.f95. Modul tu robi taku istu pracu ako class a ma aj metodu print.

[Idris]

... viz co psal Ink. Moduly jsou jen jmenné prostory ...

Never nikomu, kym si to sam neoveris.

Dobrá rada, ale vzhledem k tomu, že znám Fortran i ostatní věci, o kterých Ink psal, můžu z fleku říct, že on má pravdu a ty se ukrutně pleteš.

Jo a v tom příkladu chybí právě ty “generic bindings” aka traity.

[Wavelet]

Tak nestíhám zdejší diskuzi a nechci se tedy klonit na žádnou stranu. Podle mne je OOP i ve Fortranu, pokud se používá jen v nějakých částech aplikace, akceptovatelné. Možná poslouží i na nějaký převod původně OOP designu z C++ do Fortranu. Ale moduly jak ukazuje mikrom jsou dobrá cesta. Tak kéž by aspoň lidi ve Fortranu psali jako mikrom . Za každého Fortranistu jsem rád. Jinak co se týká teorie Idris má většinou pravdu. Proč se s ním hádat 

[Idris]

moduly jsou dobrá cesta

To tady nikdo nerozporuje, a týká se to asi všech jazyků.

A ano, buďme rádi za každého fortranistu, naprostý souhlas

[Idris]

Podle mne je OOP i ve Fortranu, pokud se používá jen v nějakých částech aplikace, akceptovatelné. Možná poslouží i na nějaký převod původně OOP designu z C++ do Fortranu.

Taky souhlas (když se používá rozumně). Ono v době přidání OOP do Fortranu zrovna letěl styl Java, bylo do dávno před (typovými systémy) Rustu, Julie či Go.

BTW co se mi z nových návrhů hodně líbí jsou šablony: https://everythingfunctional.wordpress.com/2022/07/24/the-state-of-fortran-generics/
Trochu se tváří jako ty v C++, ale s těmi omezeními (restriction) to bude super, pokud to takto projde. Kdo má furt používat m4, že?

[Idris]

ja bych si furt myslel, ze na numericke pocitani ol'good fortran

Ono to tak většinou je. Ostatně, jak jednou napsal zdejší plodný autor p. Tišnovský, Fortran je v podstatě jen DSL.

[mikrom]

... viz co psal Ink. Moduly jsou jen jmenné prostory ...

Never nikomu, kym si to sam neoveris.

Dobrá rada, ale vzhledem k tomu, že znám Fortran i ostatní věci, o kterých Ink psal, můžu z fleku říct, že on má pravdu a ty se ukrutně pleteš.

Zial neni to tak, dajme k tomu maly dokaz sporom 
Nech teda su moduly name spaces. Potom ale, ked mam 2 rozne moduly, ktore obsahuju premennu s rovnakym menom, viem jej pouzitie rozlisit na zaklade mena modulu, t.j. takto:

Kód: [Vybrat]

module MA
    character(20) :: foo = 'foo from module A'
end module MA

module MB
    character(20) :: foo = 'foo from module B'
end module MB

program namespaces
    use MA
    use MB
    write(*,*) MA%foo
    write(*,*) MB%foo
end program namespaces
Ked sa vsak pokusim skompilovat to dostanem chybu

Kód: [Vybrat]

$ gfortran namespaces.f95 -o namespaces
namespaces.f95:12:17:

     write(*,*) MA%foo
                 1
Error: Symbol at (1) is not appropriate for an expression
namespaces.f95:13:17:

     write(*,*) MB%foo
                 1
Error: Symbol at (1) is not appropriate for an expression
 
Takuto chybu dostanem aj ked namiesto % pouzijem . alebo => atd.
To znamena, ze na zaklade mena modulu sa neda rozlisit, z ktoreho modulu rovnomenna premenna je.
Z toho vyplyva, ze moduly nie su menne priestory a ty nemas pravdu 

Jinak co se týká teorie Idris má většinou pravdu. Proč se s ním hádat 

Ako som hore ukazal - je mi luto ale tentoraz pravdu nema.
Idris nam tu sice dava sebavedome a silne tvrdenia a po teoretickej stranke ma toho iste velmi vela precitane. Ale pripada mi to ako ked studuje v matematike definicie a vety bez praktickych cviceni. Moze sice ostatnych ohurovat ake je v tom eso, ale hlbsie pochopenie prichadza az pri rieseni praktickych uloh.

Moduly vo fortrane nie su namespaces. Fortran nema name spaces.
Namespaces si ale mozes v moduloch vytvorit pomocou derived data types a to takto:

Kód: [Vybrat]

module MA
    type MA_T
        character(20) :: foo = 'foo from module A'
    end type

    type(MA_T) :: A
end module MA

module MB
    type MB_T
        character(20) :: foo = 'foo from module B'
    end type

    type(MB_T) :: B
end module MB

program namespaces
    use MA
    use MB
    write(*,*) A%foo
    write(*,*) B%foo
end program namespaces

Output:

Kód: [Vybrat]

$ gfortran namespaces.f95 -o namespaces
$ ./namespaces
 foo from module A
 foo from module B