ajout de subcommandes à la commande string
#1
j'ai trouvé le moyen d'ajouter des subcommandes à string
j ai donc créé un petit package contenant 4 commandes supplémentaire

- string empty <string> : retourne 1 si string=="" sinon retourne 0
Code :
% string empty ""
1

- string xchang <string> <index1> <index2> : échange les 2 indexes
Code :
% string xchang abcdef 1 end
afcdeb

- string randomize <string> : mélange string de façon aléatoire
Code :
% string randomize abcdef
dfecba

- string sort ?-option value ...? <string> : utilise la commande lsort de façon a classer string dans l'ordre désiré (en fonction des options spécifié)
(cf man lsort pour plus d info sur les options)
Code :
% string sort -dictionary dfecba
abcdef
% string sort -dictionary -decreasing dfecba
fedcba


bien entendu les subcommandes de base de string restent actives

si vous avez des idées de subcommandes que je pourrais ajouter
C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre
#2
Bonne idée.

Quelques idées/questions en vrac :

Y'a-t-il une raison particulière à utiliser set string plutôt que return $string ?
__________
Pour une librairie de ce genre, la rapidité d'exécution est cruciale et quelques optimisations seraient les bienvenues. Même si ça n'a l'air de rien, quelques µs gagnées sur une proc exécutée plusieurs fois par seconde peuvent avoir un effet sensible.
Voici à quoi je fais allusion :
tcl
expr {$string==""}


pour tester une condition impliquant une string, eq et ne sont plus rapides que == et != (et inversement pour tester une équivalence numérique), donc :
tcl
expr {$string eq ""}


__________
tcl
set string [string replace $string $index2 $index2 $tmp]
set string [string replace $string $index1 $index1 $tmp2]


deviendrait
tcl
return [::tcl::string::replace [::tcl::string::replace $string $index2 $index2 $tmp] $index1 $index1 $tmp2]


On économise ainsi quelques instructions.
A noter aussi que ::tcl::string::replace s'exécute plus rapidement que string replace car ça épargne à l'interpréteur la peine de devoir localiser le namespace.
Même chose pour les string length qui deviendront des ::tcl::string::length et les string empty qui deviendront des ::tcl::string::empty.
__________
tcl
set j [expr {int(rand()*$len)}]
set string [string xchang $string $i $j]


pourrait s'écrire
tcl
set string [::tcl::string::xchang $string $i [expr {int(rand()*$len)}]]


et d'autres cas similaires ci et là.
Toute l'actualité de mes scripts ici     (dernière mise à jour le 22/04/2020)

Tout programme comporte au moins un bug et pourrait être raccourci d'au moins une instruction, de quoi l'on peut déduire que tout programme peut être réduit à une seule instruction qui ne fonctionne pas.
  Répondre
#3
Citation :Y'a-t-il une raison particulière à utiliser set string plutôt que return $string ?
et bien set est la syntaxe par défaut de tcl sachant que $ est un raccourci vers set "return $string" est équivalent a "return [set string]"

sinon == ou eq on un temps d'exécution strictement identique

Citation :TCL :
set string [string replace $string $index2 $index2 $tmp]
set string [string replace $string $index1 $index1 $tmp2]
deviendrait
TCL :
return [::tcl::string::replace [::tcl::string::replace $string $index2 $index2 $tmp] $index1 $index1 $tmp2]
On économise ainsi quelques instructions.
A noter aussi que ::tcl::string::replace s'exécute plus rapidement que string replace car ça épargne à l'interpréteur la peine de devoir localiser le namespace.
Même chose pour les string length qui deviendront des ::tcl::string::length et les string empty qui deviendront des ::tcl::string::empty.

j'aime bien garder un code claire d'où l utilisation de 2 lignes.
Par contre pour l'utilisation du path complet ca pourrait être une bonne idée, il y a un gain de 2us / 50us en moyenne
C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre
#4
voila j ai modifié les path,
sur un "string randomize 0123456789" le gain de performance est proche des 80% (à cause de la boucle surement)
je ne pensais pas qu'on y gagnerai autant
C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre
#5
djkenny a écrit :sinon == ou eq on un temps d'exécution strictement identique
Mes tests disent le contraire :
Citation :[01:12:48] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:48] <Boole> Tcl: 0.235 microseconds per iteration
[01:12:49] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:50] <Boole> Tcl: 0.234 microseconds per iteration
[01:12:51] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:51] <Boole> Tcl: 0.25 microseconds per iteration
[01:12:52] <MenzAgitat> .tcl time {expr {$testtest eq "test"}} 1000000
[01:12:52] <Boole> Tcl: 0.234 microseconds per iteration
Citation :[01:12:57] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:12:58] <Boole> Tcl: 0.265 microseconds per iteration
[01:12:59] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:12:59] <Boole> Tcl: 0.265 microseconds per iteration
[01:13:00] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:13:00] <Boole> Tcl: 0.265 microseconds per iteration
[01:14:03] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:14:04] <Boole> Tcl: 0.265 microseconds per iteration
[01:14:05] <MenzAgitat> .tcl time {expr {$testtest == "test"}} 1000000
[01:14:06] <Boole> Tcl: 0.265 microseconds per iteration
Toute l'actualité de mes scripts ici     (dernière mise à jour le 22/04/2020)

Tout programme comporte au moins un bug et pourrait être raccourci d'au moins une instruction, de quoi l'on peut déduire que tout programme peut être réduit à une seule instruction qui ne fonctionne pas.
  Répondre
#6
Citation :[01:22] <+Dj_KennY> &tcl time {expr {1 == 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5838 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 == 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.569 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 == 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5818 microseconds per iteration
Citation :[01:22] <+Dj_KennY> &tcl time {expr {1 eq 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5579 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 eq 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.5868 microseconds per iteration
[01:22] <+Dj_KennY> &tcl time {expr {1 eq 1}} 10000
[01:22] <+Tcl-Bot2> TCL -> 0.575 microseconds per iteration
C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre
#7
Dans mon test, il était question d'une string non-numérique, refais le test avec la même pour que les résultats soient comparables.
Toute l'actualité de mes scripts ici     (dernière mise à jour le 22/04/2020)

Tout programme comporte au moins un bug et pourrait être raccourci d'au moins une instruction, de quoi l'on peut déduire que tout programme peut être réduit à une seule instruction qui ne fonctionne pas.
  Répondre
#8
effectivement avec une variable le resultat change trés legerement

Citation :avec eq
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.04944 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.08395 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.04519 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.05083 microseconds per iteration
Citation :avec ==
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.12794 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.14497 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.12121 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.11631 microseconds per iteration
[01:31] <+Dj_KennY> &tcl time {::tcl::string::empty aaa} 100000
[01:31] <+Tcl-Bot2> TCL -> 2.1471 microseconds per iteration
mais bon la différence se compte en nano secondes :x

édit: bizarrement avec un string vide j obtient le résultat inverse
C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre
#9
Citation :avec ==
% time {::tcl::string::empty ""} 100000
1.88144 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.86438 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.89402 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.86838 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.87231 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.87639 microseconds per iteration

% time {::tcl::string::empty aaa} 100000
2.14479 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.1215 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.12854 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.12112 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.13864 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
2.12714 microseconds per iteration

Citation :avec eq
% time {::tcl::string::empty ""} 100000
1.97091 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.98191 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.99542 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.97693 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.96448 microseconds per iteration
% time {::tcl::string::empty ""} 100000
1.98486 microseconds per iteration

% time {::tcl::string::empty aaa} 100000
1.90619 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.90897 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.91097 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.90607 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.93027 microseconds per iteration
% time {::tcl::string::empty aaa} 100000
1.90746 microseconds per iteration
C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre
#10
Je bave quand je vois votre niveau dans ce langage !
CrazyCat a écrit :La prochaine fois, essaye d'imaginer que j'ai un cerveau ...
  Répondre
#11
après quelques test complémentaire jai décidé d utiliser string equal
tcl
proc ::tcl::string::empty string {
        ::tcl::string::equal $string ""
}


C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre
#12
BdS a écrit :Je bave quand je vois votre niveau dans ce langage !

Ouais assez sympa, j'ai appris pas mal de chose en quelque postes ^^
  Répondre
#13
salut,

la dernière version
C'est en reconnaissant ses erreurs que l'on progresse ;)
Absent
  Répondre


Atteindre :


Utilisateur(s) parcourant ce sujet : 1 visiteur(s)