Discussion :

[fred1599]

Bonjour,

Je cherche à parser une chaîne de caractère dont la principale caractéristique est d'être un nombre décimal est d'avoir décomposé cette chaîne pour avoir deux entiers.

Exemple:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

"3.14" -> x=3 et y=14

Sur le principe c'est un split, j'ai cherché aussi du côté de sscanf et j'arrive à cette conclusion

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
program test
 
    character(len=4) :: t="3.14"
    integer :: a, b
    call str(t, a, b)
 
    print*, a
    print*, b
 
contains
    subroutine str(n, x, y)
        character(len=*), intent(in) :: n
        integer, intent(out) :: x, y
        integer :: ind
 
        ind = index(n, '.')
        read(n(1:ind-1), *) x
        read(n(ind+1:len_trim(n)), *) y
 
    end subroutine str
 
end program test

Seulement c'est lent, l'objectif est de transformer cette subroutine en une fonction utilisable vers python. Quand je compare les fonctions split et int à ma fonction fortran, je suis 2 fois plus lent. C'est pourquoi je viens vous demander s'il y a plus efficace comme méthode...

Merci par avance.

[Ehouarn]

Bonjour,

Coté code j'aurai fait essentiellement la même chose, mais avec plus de contrôles pour gérer les cas particuliers:
Que se passe t'il si il n'y a pas de '.' dans la chaîne à traiter? Ou si il est en première ou dernière place?

Coté performances, ça dépends aussi des options d'optimisation utilisées à la compilation...

[fred1599]

Coté code j'aurai fait essentiellement la même chose, mais avec plus de contrôles pour gérer les cas particuliers:

C'est du côté python que je fais cela...

Coté performances, ça dépends aussi des options d'optimisation utilisées à la compilation...

L'option est O3. Donc le plus optimisé... Mais c'est pas grave j'ai interfacé avec du C, je suis 11x plus rapide. Faudra que je vois avec des langages plus spécialisés dans le domaine d'analyse de texte comme awk par exemple.

[Sylvain Bergeron]

En Fortran, les lectures / écritures formatées sont très lentes depuis longtemps.

Le code suivant n'est pas robuste, mais te permettrait de voir dans quelle mesure tu peux réduire le temps en évitant les read :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
program test
 
    character(len=4) :: t="3.14"
    integer :: a, b
    call str(t, a, b)
 
    print*, a
    print*, b
 
contains
    subroutine str(n, x, y)
        character(len=*), intent(in) :: n
        integer, intent(out) :: x, y
        integer :: ind, k
 
        ind = index(n, '.')
!       read(n(1:ind-1), *) x
        x = 0
        do k = 1, ind - 1
            x = x * 10 + ichar(n(k:k)) - 48
        enddo
!       read(n(ind+1:len_trim(n)), *) y
        y = 0
        do k = ind + 1, len_trim(n)
            y = y * 10 + ichar(n(k:k)) - 48
        enddo
 
    end subroutine str
 
end program test

[fred1599]

Bravo ! On a l'équivalence du C à 0,6s sur 10000000 itérations, excellent interfaçage ce fortran. Merci !!!

EDIT: à 0,4 s avec optimisation (--opt='-O3').

Par contre faut que je tente le même algorithme pour le C afin de comparer plus justement mes deux interfaçages.

EDIT2: Avec le même algo, via cython, on arrive à 2,5x le temps fortran, mais je suis content de voir que ce langage tient la dragée haute, ça me motive à continuer l'apprentissage. J'ai pas vu d'équivalent à ces deux langages...

EDIT3: J'ai vu plus rapide avec le langage julia (10x).