Discussion :

[Aguire_]

Bonjour.

A la base j'utilise un tableau bidimensionnel du genre TABLEAU(col,lignes):
Dim TBLA.b (100,100000)
Ce tableau contient comme éléments soit 0 soit 1 .

Pour continuer j'additionne une sélection de colonnes (2,3,4 ou plus).
Le grand nombre de permutations possible entre colonnes, représente le gros du traitement, plusieurs milliers de tests voir plus.

Exemple:

Resultat(lignes) =TBLA(1,lignes)+TBLA(5,lignes)+TBLA(80,lignes)

J'obtiens bien pour chaque ligne du Tableau Résultat ,la somme des Colonnes sélectionnées.

= = =

Ma question est

Existe t'il une méthode plus efficace/rapide pour faire l'addition de colonnes, que l'utilisation d'une boucle (debut/fin de ligne) ?

Une Sorte de SWAP ou CopyMemory / une librairie ?


Ma Seule amélioration permettant un gain de temps d'exécution fut de passer du Tableau Bidimensionnel en tableau Unidimensionnel, l'alignement en mémoire des valeurs devant y jouer .

Un passage du Tableau unidimensionnel en pointeur, permettrait'il un Gain suplémentaire en temps de calcul?

Voila merci pour toute infos.

[comtois]

Salut

c'est absolument nécessaire de faire un tableau de byte ?
Il parait qu'il est préférable de travailler avec des variables qui sont dans le même format que le système, en l'occurrence des integer avec PureBasic, tes variables seront de 32 ou 64 bits selon ton système. les autres formats comme les bytes, long ou autres sont utiles quand tu as besoin de travailler avec l'API.

J'ignore si tu gagneras du temps ? Je te laisse faire l'essai.

Ensuite tu parles de permutations possible entre colonnes ou de Une Sorte de SWAP ou CopyMemory

et l'exemple que tu donnes consiste à faire des additions.

Du coup, je ne comprends pas trop ton problème.

En tout cas les fonctions Swap et CopyMemory existent sous PureBasic.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
Dim Tab(2,3)
Tab(2,3) = 65
Tab(1,2) = 23
 
Debug "Avant le Swap"
Debug Tab(2,3)
Debug Tab(1,2)
 
Swap Tab(2,3), Tab(1,2)
 
Debug "Après le Swap"
Debug Tab(2,3)
Debug Tab(1,2)

Un passage du Tableau unidimensionnel en pointeur

Pourquoi tu ne le testes pas dans ton application ? tu aurais une mesure concrète du gain éventuel.

[Aguire_]

Salut.

Merci Comtois, pour la réponse et les exemple.

Le Tableau contient bien des valeurs 0 ou 1 (binaire), déclaration faite depuis en Long. J'ignorais que les integer étaient plus "performants", je referais un test .( le passage TAB.b en TAB.l ayant apporté un petit gain)

Il y a en effet la bibliotheque Memory & la fonction SWAP (permutation)

SWAP est rapide et "facile" à comprendre et mettre en oeuvre.
(pour la permutation d'élements au moins)

Comparememory fonctionne selon l'exemple pour 2 zones "mémoire". Cela reste utilisable pour comparer 2 tableaux ou pourquoi pas 2 zones du meme tableau. On reste sur 2 Zones.

= = =

Tableau unidimensionnel en pointeur, cela reste mon sujet de recherche, un exemple de base me servirait beaucoup.
L'aide parle de tableau de points = Dim Tableau.Point(1) ?

Pour des tableaux en b,i,l ou autre ?

Pour une addition d'une ou plusieurs zone d'un tableau, le code n'est pas différent en pointeur qu'en "normal" .

for i = zone to total
Resultat(zone) = pointeur(zoneA) + pointeur(zoneB) + pointeur(zoneC)...
next zone

Un petit exemple me serait bien utile et instructif.

+

[comtois]

Je ne sais pas si tu gagneras du temps avec ça, mais à titre d'information voici un exemple, je l'ajouterai à la FAQ à l'occasion :

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
Dim Tab(100)
Define *Ptr.Integer
 
;Une petite valeur dans le tableau
Tab(56) = 87
 
;Récupère l'adresse du tableau
*Ptr = @Tab() 
 
;Pointe sur l'élément 56 du tableau 
*Ptr + 56 * SizeOf(Integer) ; On a un tableau d'integer
 
;Affiche la valeur qui se trouve à l'adresse pointée par *Ptr
Debug *Ptr\i
 
;Il est possible de récupérer directement l'adresse d'un élément 
*Ptr = @Tab(56)
 
;Affiche la valeur qui se trouve à l'adresse pointée par *Ptr
Debug *Ptr\i

Pour un tableau à deux dimensions

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
 
Dim Tab(100,200)
Define Largeur
Define *Ptr.Integer
 
;Calcul la largeur du tableau, on ne fait qu'une fois le calcul
Largeur = ArraySize(Tab(),2)+1
 
;Une petite valeur dans le tableau
Tab(5,6) = 87
 
;Récupère l'adresse du tableau
*Ptr = @Tab() 
 
;Pointe sur l'élément Tab(5,6) du tableau 
*Ptr + (5 * Largeur + 6) * SizeOf(Integer) ; On a un tableau d'integer
 
;Affiche la valeur qui se trouve à l'adresse pointée par *Ptr
Debug *Ptr\i
 
;Il est possible de récupérer directement l'adresse d'un élément 
*Ptr = @Tab(5,6)
 
;Affiche la valeur qui se trouve à l'adresse pointée par *Ptr
Debug *Ptr\i

[Aguire_]

Voici un petit bout de code comparaison de la vitesse de traitement de données entre une "boucle traditionnelle" et une boucle utilisant les pointeurs, soit l'addition de 8 Zones d'un Tableau unidimensionnel .

Il m'a fallut un peu de pratique et de test pour comprendre le fonctionnement des pointeurs, cela marche, du moins avec la maniere utilisée dans cet exemple.
Je ne sais si c'est la meilleure façon de procéder, considérons cela comme un apprentissage sur les Tableaux et Pointeurs.

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
 
;==================================================
; Controle de la vitesse D'execution de 2 Codes
; Vitesse 1 = 20 078 
; Vitesse 2 =  7 016
;================================================== 
DisableDebugger
#nb = 10000   ; longueur de boucle de test
;==================================================
total.i = 100000000 ; - Longueur du tableau Unidimensionnel
Dim Tab(total)
Define *Ptr.Integer   ; Definition Pointeur
;- Remplir tableau avec 1
For i = 1 To total
  Tab(i) = 1   
Next i 
;
;================================================== 
Temps1 = ElapsedMilliseconds()  ; Code Routine 1 
;================================================== Temps 1
For n.l = 1 To #nb
;==================================================
; mettre ici votre code TEST 1
 
  For zz.l = 1 To 100000 ; - Longueur Tableau à additionner
 
    *Ptr = @Tab(zz) 
      test = *Ptr\i
    *Ptr = @Tab(zz+100000) 
      test + *Ptr\i
    *Ptr = @Tab(zz+200000) 
      test + *Ptr\i
    *Ptr = @Tab(zz+300000) 
      test + *Ptr\i
    *Ptr = @Tab(zz+400000) 
      test + *Ptr\i
    *Ptr = @Tab(zz+500000) 
      test + *Ptr\i
    *Ptr = @Tab(zz+600000) 
      test + *Ptr\i
    *Ptr = @Tab(zz+700000) 
      test + *Ptr\i   
 
 
  Next zz
 
;==================================================
Next n
;==================================================
Temps2 = ElapsedMilliseconds() ; Code Routine 2
;================================================== Temps 2
For n = 1 To #nb
;==================================================
; mettre ici votre code Test 2  
 
 For lulu.l = 1 To 100000 ; - Longueur Tableau à additionner
 
  resultat.l = Tab(lulu) + Tab(lulu+100000) + Tab(lulu+200000) + Tab(lulu+300000) + Tab(lulu+400000) + Tab(lulu+500000)+ Tab(lulu+600000)+ Tab(lulu+700000)
 
 Next lulu   
 
;==================================================
Next n
;==================================================
 
Temps3 = ElapsedMilliseconds()
 
MessageRequester("Test rapidité", "Solution 1 : " + Str(Temps2 - Temps1) + " ; Solution 2 : " + Str(Temps3 - Temps2) + Chr(10) + "Ratio = 1 / " + StrF((Temps2 - Temps1) / (Temps3 - Temps2)), 0)
 
EnableDebugger
;
;
Debug "Resutat avec Pointeur =  " +Str(test)
;
Debug "Resutat sans Pointeur =  " +Str(resultat)
;

Juste un point de détail.
Vu le type de pointeur defini en Integer
Doit'on definir le Tableau // Dim Tab(total) // en
Dim Tab.i(total) .

Apres Test, avantage à la boucle additive traditionnelle, la passage en pointeur n'apportant pas de gain.(dans cet exemple de base toutefois !).

[comtois]

Juste un point de détail.
Vu le type de pointeur defini en Integer
Doit'on definir le Tableau // Dim Tab(total) // en
Dim Tab.i(total) .

Le type integer est le type par défaut, donc si tu ne précises rien pour ton tableau il sera forcément du type integer, idem pour les variables, les listes chainées, etc.

Sinon l'utilisation des tableaux est optimisée par le compilateur. Donc difficile de faire mieux et plus rapide. C'est plus ton algorithme qu'il faut améliorer que l'usage des tableaux. Par exemple, pose toi la question 'est-il possible de stocker des calculs intermédiaires ?' , ou ne faire le calcul que si une donnée change dans une cellule du tableau ,et ne refaire que les calculs des parties concernées ? en gérant des sous totaux par ligne ou par colonne, ça dépend de ton utilisation.

Cependant il y a sans doute des cas pour lesquels l'usage des pointeurs sera plus rapide, je n'ai pas d'exemple en tête. C'est pourquoi il est toujours bon de s'exercer aux joies des pointeurs, tôt ou tard tu y viendras naturellement et tu te demanderas comment tu as fait pour t'en passer jusque là

[chourmovs]

haaaa les pointeurs, j'avais réussi a comprendre dans ma jeunesse mais après de bons nœuds au cerveau
Il y'a un bon didacticiel pour les nuls, avec des images, sur l'utilisation des pointeurs ?

[comtois]

En attendant que quelqu'un écrive ce tutoriel, pour résumer sommairement :

Un pointeur c'est une variable qui contient une adresse et rien d'autre. Syntaxe d'un pointeur sous PureBasic :

Code :

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

*MonPointeur

Pour connaitre l'adresse d'une variable, d'un tableau, d'une procédure, etc il faut mettre un arobas devant, exemple :

Code :

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

1
2
3
Define MaVariable.w
;Affiche l'adresse de MaVariable
Debug @MaVariable

Pour modifier MaVariable à l'aide d'un pointeur, il faut définir un pointeur du même format que la variable (c'est pas indispensable mais c'est plus pratique).

Code :

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

Define *MonPointeur.Word

Comme la variable MaVariable est un word, on associe la structure Word au pointeur *MonPointeur.

Et maintenant il faut que *MonPointeur connaisse l'adresse de MaVariable :

Code :

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

*MonPointeur = @MaVariable

Désormais il est possible de modifier le contenu de MaVariable par le biais de *MonPointeur.

Code :

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

1
2
3
4
5
6
7
8
9
10
Define MaVariable.w
Define *MonPointeur.Word
 
*MonPointeur = @MaVariable
;Affiche le contenu de MaVariable avant modification
Debug MaVariable
;Modifie le contenu de MaVariable
*MonPointeur\w = 12
;Affiche le contenu de MaVariable après modification
Debug MaVariable

Si tu n'avais pas défini ton pointeur dans le même format que MaVariable, tu pouvais utiliser la fonction Poke, mais c'est moins lisible à mon avis !

Code :

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

1
2
3
4
5
6
7
8
9
10
Define MaVariable.w
Define *MonPointeur
 
*MonPointeur = @MaVariable
;Affiche le contenu de MaVariable avant modification
Debug MaVariable
;Modifie le contenu de MaVariable
PokeW(*MonPointeur, 12)
;Affiche le contenu de MaVariable après modification
Debug MaVariable

[Myshl]

Tutos pointeurs ?

Vous offre les liens vers deux moteurs de recherches spécialisés pdf.

Je considère les documents pdf en principe plus aboutis que tout autre document,
notamment pas mal de cours dispensés en universités ou ailleurs sont disponibles en fichiers pdf,
la pédagogie renforce l'information.

http://www.yopdf.com/pointeurs-pdf.html
http://pdf-tuts.com/pointeurs.html

Myshl