Zobrazit příspěvky
Tato sekce Vám umožňuje zobrazit všechny příspěvky tohoto uživatele. Prosím uvědomte si, že můžete vidět příspěvky pouze z oblastí Vám přístupných.
Zial neni to tak, dajme k tomu maly dokaz sporomDobrá 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š.... viz co psal Ink. Moduly jsou jen jmenné prostory ...Never nikomu, kym si to sam neoveris.
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
$ 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
Jinak co se týká teorie Idris má většinou pravdu. Proč se s ním hádatAko som hore ukazal - je mi luto ale tentoraz pravdu nema.
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
$ gfortran namespaces.f95 -o namespaces
$ ./namespaces
foo from module A
foo from module B
... 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.
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
$ 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)
a jak vies ze tie rozsirenia su pekne, ked si povedal ze vo fortrane neprogramujesja 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.
btw. ja som asi iba raz v zivote experimentalne pouzil OpenMP
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
$ 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)
suhlasim s tebou na 100%, ze OOP je vo fortrane zbytocneveortranu bych ocekaval praci s vektory, maticemi, na co specialni typ pro kvaterniony.fortran to umoznuje
proto to pisu, ze fortran je na numeriku a traits a oop jsou v nem zbytecne.
veortranu bych ocekaval praci s vektory, maticemi, na co specialni typ pro kvaterniony.fortran to umoznuje
No to som trochu sklamanyTo mě mrzí. Slibuji, že až bude chvilka času, nainstaluju si GNU Fortran a napíšu příklad. Ovšem vzhledem k charakteru OOP ve Fortranu ten kód bude hnusný a jako příklad spíše negativní
tak to radsej ani nedavaj. No to som trochu sklamany, myslel som ze ked je to pre Teba trivialne, tak sem das aspon nejaky kusok fungujuceho kodu, aby sa aj ostatni od teba nieco priucili. Ja som sem dal 2 analogicke priklady:Tak preco neurobis syntaktickou omáčkou male demo traitu vo fortrane ?Protože to nepotřebuju a navíc to je triviální a úplně stejné jako třeba v Javě bez rozhraní (její úplně prvotní verze, asi ještě pre-v1.0, je ostatně neměla). Napsat něco jako rustí std::io::Read nebo io.Reader (Go) bez použití traitů/rozhraní a bez vícenásobné dědičnosti bývá oblíbená otázka u zkoušek z úvodu do “OOP”.
Nech je to funkcne, da sa skompilovat v gfortrane a ma zmysluplne pouzitie ..
Žádný průnik tam není.Moduly vo fortrane (90+) maju podobny ucel ako traity v inych jazykoch. Sluzia na organizaciu a znovupouzitie kodu.
Možná jsem něco nepochopil, ale co jsi demonstroval ve svém příkladu, jsou funkce uspořádané do nějakých namespaces. Traity slouží k implementaci nějakého rozhraní napříč různými typy (třídami). Možná tam někde nějaký průnik vidíš, ale nepřijde mi, že by tam byla nějaká zásadní podobnost nebo zastupitelnost.
class Main implements my_mod {
static void main(String[] args) {
Main m = new Main();
println("main calls:")
m.t11()
m.t12()
m.t2()
m.s()
}
}
trait tmp_mod1 {
void t11() {
println("t11");
}
void t12() {
println("t12 calls:")
t11()
}
}
trait tmp_mod2 {
void t2() {
println("t2")
}
}
trait my_mod implements tmp_mod1, tmp_mod2 {
void s() {
println("s calls:")
t11()
t12()
t2()
}
}
main calls:
t11
t12 calls:
t11
t2
s calls:
t11
t12 calls:
t11
t2
Ty traity se dají udělat syntaktickou omáčkouTak preco neurobis syntaktickou omáčkou male demo traitu vo fortrane ?
Moduly vo fortrane (90+) maju podobny ucel ako traity v inych jazykoch. Sluzia na organizaciu a znovupouzitie kodu.
Možná jsem něco nepochopil, ale co jsi demonstroval ve svém příkladu, jsou funkce uspořádané do nějakých namespaces. Traity slouží k implementaci nějakého rozhraní napříč různými typy (třídami). Možná tam někde nějaký průnik vidíš, ale nepřijde mi, že by tam byla nějaká zásadní podobnost nebo zastupitelnost.
jako decko jsem vyhrabal kdovikde knizku algol-cobol-fortran a co jsem videl jsem nechapal, ale obdivoval to jako magii. no ve fortranu jsem si uz zaprogramoval, ty dva ostatni me minuly. delam v c++.
https://knihobot.cz/g/497729
No páni! Taky jsem se podle ní učil programovat. To je let, odhaduju 1978..
Ale hlavně z tohoto ..
https://www.databazeknih.cz/knihy/fel-fortran-prirucka-uzivatele-423628
Doc. Koníček , FEL Fortran
Root.cz (www.root.cz), informace nejen ze světa Linuxu. ISSN 1212-8309
Copyright © 1998 – 2023 Internet Info, s.r.o. Všechna práva vyhrazena. Powered by Linux.