Le topic de la programmation, string, chaînes, cuir et compagnie

[Sahnvour]

Au boulot on a celui-là, il est pas très fancy (et pas cher il me semble) mais au moins il est assez silencieux.

[Mayalabielle]

Coucou les copins,


Je me cherche un "bon clavier" AZERTY pour coder au boulot. Ceux qu'on a sont un peu moisis, franchement moisis même.
J'ai besoin d'un truc qui soit silencieux sinon je vais simplement me faire lyncher sur place. A la maison, j'ai un Corsair avec switchs MX red montés sur une base métallique: autant le niveau de bruit passe nickel à usage domestique, autant je pense que c'est un peu too much au taff.

Le type clavier portable avec touches plates à fond, c'est pas forcément mon truc, mais ce sera déja nettement mieux que ce qu'on nous a infligé jusqu'ici.
Des idées??

Quand j'ai besoin d'être silencieux je sors mon TypeMatrix, mais bon c'est du "touches plates à fond" huhu.

[Mayalabielle]

Pour les programmeurs et programmeuses souhaitant découvrir le monde de la programmation fonctionnelle, je conseille Elixir (que je suis entrain d'apprendre). Langage très complet et je trouve, très simple/clair. Très rapidement on peut se faire plaisir avec Phoenix, son Framework web et construire rapidos une application web pas dégueu. Pour un tour rapide du langage, Elixir School est top https://elixirschool.com/en/lessons/basics/basics/.

[ducon]

Oh, il y a un paquet pour Debian.

[2501]

Salut tout le monde,
j'ai un fichier avec des "liens" de la forme [[uri][description]]
le truc, c'est que certains (uris "mailto:" ) ont une description pétée, et comme il y en pas mal,
je pensais remplacer la description par "l'uri moins le mailto" (je ne peux pas mettre de description vide, mais je peux mettre un lien sans description: [[uri]])

Pour l'instant, tout ce que j'ai réussi à faire (en sed), c'est:

#match n'importe quel [[mailto:mail][desc]] avec un mailto dedans
/\[\[mailto:.*@.*\]\[.*\]\]/{
#si le champ desc contient un mail valide, pas besoin d'edit
/\[\[mailto:.*@.*\]\[.*@.*\]\]/b end
#rappel: le match contient toute la ligne
#remplacer la fin avec le truc incorrect par du vide
s/\]\[.*\]\]/]]/
:end
}

et je me retrouve avec uniquement des [[mailto:.*@.*]] valides.

Le truc, c'est que je n'arrive pas à me figurer comment mettre l'uri dans la description en enlevant le préfixe (la ligne contient d'autres trucs, en plus...)

[ducon]

Ton Uri Geller ne tord pas les cuillers, c’est pour ça.

[Lazyjoe]

Tout bêtement avec la commande cut ?

[2501]

@ducon
ça c'est tordu

Pour cut, tu pensais à un truc comme ça ?:

line="blabla [[mailto:john.doe@example.com]] blublublu"; echo  -n $line | cut -d ] -f 1 ; echo -n "][";  echo -n $line  | cut -d ':' -f 2 | cut -d ']' -f 1; echo -n ']]'; echo -n $line | cut -d ']' -f 3

(bon j'ai des problèmes avec les newlines, mais flemme de paufiner)

[2501]

Victoire !
j'ai trouvé un autre truc pour mettre le premier champ tout en enlevant "mailto:" dans la description (en utilisant le premier script puis celui-ci), toujours en sed

#match n'importe quel [[mailto:john.doe@example.com]] ou [[mailto:john.doe@example.com][desc]]
#en fait j'aurais dû utiliser les \+ depuis le début pour la répétition car il ne peut pas y avoir
#"rien du tout" devant ou après un @
/\[\[mailto:.\+@.\+\]\]/{
#si il contient déjà une description, on branche à la fin (le premier script a fait en sorte que tous les
#champs "description" soient un mail)
/\[\[mailto:.\+@.\+\]\[.*\]\]/b end
#doc sed:
#pour les remplacements, on peut utiliser \d avec d un chiffre. Cela est remplacé par la d-ième
#sous-expression régulière groupée \(\) (je traduis comme je peux)
#ici j'utilise [^]] pour dire "tous les caractères sauf ]" pour éviter d'englober les deux ]] de la fin avec \+
#et j'englobe la partie après le mailto et avant le ']' final (j'englobe tout de même un ']')
s/mailto:\(.\+@[^]]\+\)\]/&[\1]/
:end
}

[Kamasa]

Si je pige bien ton truc, c'est basé sur des expressions régulières non ?
Tu peux pas faire "placer" ton mailto: dans un groupe non-capturant et mettre le reste dans un groupe capturant ?
Grosso-merdo :
(?:mailto:)?(.*)

http://www.regular-expressions.info/refcapture.html

[Mayalabielle]

Si je pige bien ton truc, c'est basé sur des expressions régulières non ?
Tu peux pas faire "placer" ton mailto: dans un groupe non-capturant et mettre le reste dans un groupe capturant ?
Grosso-merdo :
(?:mailto:)?(.*)

http://www.regular-expressions.info/refcapture.html

ouais.

[2501]

Oui, c'est basé sur des expressions régulières (c'est la commande "sed" version GNU)
sed utilise POSIX BRE selon ton site, donc ce type de syntaxe n'a pas l'air d'être pris en charge

En gros ce que tu proposes, c'est de faire un match avec le mailto: "sans la capture" puis capturer ce qui est derrière ? (c'est vrai que ça simpliefirait beaucoup de choses...)
Problème: je n'ai aucune idée de comment faire ça avec sed

[Kamasa]

string='[[mailto:mail.truc@domaine.ext]]'
echo "$string" | sed -rn 's/[^\[\[(?:mailto:)?(.*?)\]\]/\1/p'

Ca devrait ressembler plus-ou-moins a un truc du genre.

EDIT : ha bah en fait t'es bel et bien niqué parce que Sed ne supporte pas la syntaxe des groupes non-capturant dans une expression régulière. Comme tu l'avais fait remarqué mais j'avais pas bien fais gaffe...
Donc tu vas rester sur ta précédente solution

[Nattefrost]

Ou écrire un script perl/python au lieu de sed pour utiliser cette feature. Sed c'est pratique mais ca devient très vite moche, à tel point que même du perl c'est plus propre , à toi de juger si c'est overkill ou pas.

[2501]

Oh j'avais pas vu, sed a une option -r / -E pour activer ERE
Mais même comme ça, ça n'a pas l'air de fonctionner
Il me sort un "expression n°1, caractère 34: référence \1 invalide dans le côté droit de la commande `s'" quand j'essaie ta version.
Pas l'impression qu'il comprenne le groupe non-capturant.
Juste une question, à quoi sert le '[^' au début ?

- - - Mise à jour - - -

@Nattefrost:
Pour l'instant j'ai réussi à bidouiller mon fichier comme je le souhaitais avec mes deux bouts de sed, mais si jamais je dois recommencer ou refaire ça pour des patterns différents, je crois que j'écrirai un script python, ça va peut-être être plus simple...

@Kamasa:
Sorry, j'avais pas vu ton edit. :j'airiendit:

[Kamasa]

Pour répondre à la question du '[^' au début, c'est une erreur
La bonne syntaxe aurait du être '^[....$'
Le caractère '^' indiquant le début de ma chaîne et le caractère '$' (que je n'ai pas mis dans mon exemple... preuve d'un travail ni fait, ni à faire) indique la fin de ma chaine.

[2501]

Finalement tout est bien qui finit bien, j'ai réussi à faire tenir tout ce que je voulais dans un seul script sed
Pour ceux qui voudraient savoir (on dirait une soupe de regexp )

#match n'importe quel [[mailto:]]
/\[\[mailto:.\+@.\+\]\]/{
#on teste si le lien est un lien long
/\[\[mailto:.\+@.\+\]\[.\+\]\]/{
    #on teste si la description est égale au mailto
    #si oui:fin du traitement de la ligne
    /mailto:\(.\+@[^]]\+\)\]\[\1\]/b end
    #sinon on remplace la description
    s/\[\[mailto:\(.\+@.\+\)\]\[.\+\]/[[mailto:\1][\1]]/
    bend
    }
#ici le lien est un lien court
#on va donc ajouter une description
s/mailto:\(.\+@[^]]\+\)\]/&[\1]/
:end
}

"\d m'a sauver"

[Nattefrost]

@2501

Sed c'est pratique mais ca devient très vite moche [...]

[Møgluglu]

La vectorisation, en 2017 c'est encore compliqué.

Code en entrée :

#pragma unroll
  for (int j = 0; j < 8; ++j)
#pragma clang loop vectorize(enable) vectorize_width(8)
    for (int i = 0; i < 8; ++i) {
      int c = c0 + 8 * j - 1 + i;
      A[c]=0.33333*(B[c-1]+B[c]+B[c+1]);
    }

Code en sortie :

	mov	rax, qword ptr [rsp - 32] # 8-byte Reload
	movsxd	rsi, eax
	mov	rax, rsi
	or	rax, 1
	vmovupd	ymm0, ymmword ptr [rsp + 4*rsi + 24]
	vpermilpd	xmm1, xmm0, 1   # xmm1 = xmm0[1,0]
	vmovups	ymm2, ymmword ptr [rsp + 4*rsi + 56]
	vblendps	ymm3, ymm0, ymm2, 1 # ymm3 = ymm2[0],ymm0[1,2,3,4,5,6,7]
	vpermps	ymm3, ymm8, ymm3
	vaddps	ymm0, ymm0, ymm3
	vmovss	xmm3, dword ptr [rsp + 4*rsi + 48] # xmm3 = mem[0],zero,zero,zero
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 52], 16 # xmm3 = xmm3[0],mem[0],xmm3[2,3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 56], 32 # xmm3 = xmm3[0,1],mem[0],xmm3[3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 60], 48 # xmm3 = xmm3[0,1,2],mem[0]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rax + 32], 16 # xmm1 = xmm1[0],mem[0],xmm1[2,3]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 40], 32 # xmm1 = xmm1[0,1],mem[0],xmm1[3]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 44], 48 # xmm1 = xmm1[0,1,2],mem[0]
	vinsertf128	ymm1, ymm1, xmm3, 1
	vaddps	ymm0, ymm0, ymm1
	vcvtps2pd	ymm1, xmm0
	vextractf128	xmm0, ymm0, 1
	vcvtps2pd	ymm0, xmm0
	vmulpd	ymm0, ymm0, ymm10
	vmulpd	ymm1, ymm1, ymm10
	vcvtpd2ps	xmm1, ymm1
	vcvtpd2ps	xmm0, ymm0
	vinsertf128	ymm0, ymm1, xmm0, 1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1068], ymm0
	vpermilpd	xmm0, xmm2, 1   # xmm0 = xmm2[1,0]
	vmovups	ymm1, ymmword ptr [rsp + 4*rsi + 88]
	vblendps	ymm3, ymm2, ymm1, 1 # ymm3 = ymm1[0],ymm2[1,2,3,4,5,6,7]
	vpermps	ymm3, ymm8, ymm3
	vaddps	ymm2, ymm2, ymm3
	vinsertps	xmm0, xmm0, dword ptr [rsp + 4*rsi + 68], 16 # xmm0 = xmm0[0],mem[0],xmm0[2,3]
	vinsertps	xmm0, xmm0, dword ptr [rsp + 4*rsi + 72], 32 # xmm0 = xmm0[0,1],mem[0],xmm0[3]
	vinsertps	xmm0, xmm0, dword ptr [rsp + 4*rsi + 76], 48 # xmm0 = xmm0[0,1,2],mem[0]
	vmovss	xmm3, dword ptr [rsp + 4*rsi + 80] # xmm3 = mem[0],zero,zero,zero
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 84], 16 # xmm3 = xmm3[0],mem[0],xmm3[2,3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 88], 32 # xmm3 = xmm3[0,1],mem[0],xmm3[3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 92], 48 # xmm3 = xmm3[0,1,2],mem[0]
	vinsertf128	ymm0, ymm0, xmm3, 1
	vaddps	ymm0, ymm2, ymm0
	vcvtps2pd	ymm2, xmm0
	vextractf128	xmm0, ymm0, 1
	vcvtps2pd	ymm0, xmm0
	vmulpd	ymm0, ymm0, ymm10
	vmulpd	ymm2, ymm2, ymm10
	vcvtpd2ps	xmm2, ymm2
	vcvtpd2ps	xmm0, ymm0
	vpermilpd	xmm3, xmm1, 1   # xmm3 = xmm1[1,0]
	vmovups	ymm4, ymmword ptr [rsp + 4*rsi + 120]
	vblendps	ymm5, ymm1, ymm4, 1 # ymm5 = ymm4[0],ymm1[1,2,3,4,5,6,7]
	vpermps	ymm5, ymm8, ymm5
	vaddps	ymm1, ymm1, ymm5
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 100], 16 # xmm3 = xmm3[0],mem[0],xmm3[2,3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 104], 32 # xmm3 = xmm3[0,1],mem[0],xmm3[3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 108], 48 # xmm3 = xmm3[0,1,2],mem[0]
	vmovss	xmm5, dword ptr [rsp + 4*rsi + 112] # xmm5 = mem[0],zero,zero,zero
	vinsertps	xmm5, xmm5, dword ptr [rsp + 4*rsi + 116], 16 # xmm5 = xmm5[0],mem[0],xmm5[2,3]
	vinsertps	xmm5, xmm5, dword ptr [rsp + 4*rsi + 120], 32 # xmm5 = xmm5[0,1],mem[0],xmm5[3]
	vinsertps	xmm5, xmm5, dword ptr [rsp + 4*rsi + 124], 48 # xmm5 = xmm5[0,1,2],mem[0]
	vinsertf128	ymm3, ymm3, xmm5, 1
	vaddps	ymm1, ymm1, ymm3
	vcvtps2pd	ymm3, xmm1
	vinsertf128	ymm0, ymm2, xmm0, 1
	vextractf128	xmm1, ymm1, 1
	vcvtps2pd	ymm1, xmm1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1100], ymm0
	vmulpd	ymm0, ymm3, ymm10
	vcvtpd2ps	xmm0, ymm0
	vmulpd	ymm1, ymm1, ymm10
	vcvtpd2ps	xmm1, ymm1
	vinsertf128	ymm0, ymm0, xmm1, 1
	vpermilpd	xmm1, xmm4, 1   # xmm1 = xmm4[1,0]
	vmovups	ymm2, ymmword ptr [rsp + 4*rsi + 152]
	vblendps	ymm3, ymm4, ymm2, 1 # ymm3 = ymm2[0],ymm4[1,2,3,4,5,6,7]
	vpermps	ymm3, ymm8, ymm3
	vaddps	ymm3, ymm4, ymm3
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 132], 16 # xmm1 = xmm1[0],mem[0],xmm1[2,3]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 136], 32 # xmm1 = xmm1[0,1],mem[0],xmm1[3]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 140], 48 # xmm1 = xmm1[0,1,2],mem[0]
	vmovss	xmm4, dword ptr [rsp + 4*rsi + 144] # xmm4 = mem[0],zero,zero,zero
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 148], 16 # xmm4 = xmm4[0],mem[0],xmm4[2,3]
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 152], 32 # xmm4 = xmm4[0,1],mem[0],xmm4[3]
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 156], 48 # xmm4 = xmm4[0,1,2],mem[0]
	vinsertf128	ymm1, ymm1, xmm4, 1
	vaddps	ymm1, ymm3, ymm1
	vcvtps2pd	ymm3, xmm1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1132], ymm0
	vextractf128	xmm0, ymm1, 1
	vcvtps2pd	ymm0, xmm0
	vmulpd	ymm0, ymm0, ymm10
	vmulpd	ymm1, ymm3, ymm10
	vcvtpd2ps	xmm1, ymm1
	vcvtpd2ps	xmm0, ymm0
	vinsertf128	ymm0, ymm1, xmm0, 1
	vpermilpd	xmm1, xmm2, 1   # xmm1 = xmm2[1,0]
	vmovups	ymm3, ymmword ptr [rsp + 4*rsi + 184]
	vblendps	ymm4, ymm2, ymm3, 1 # ymm4 = ymm3[0],ymm2[1,2,3,4,5,6,7]
	vpermps	ymm4, ymm8, ymm4
	vaddps	ymm2, ymm2, ymm4
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 164], 16 # xmm1 = xmm1[0],mem[0],xmm1[2,3]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 168], 32 # xmm1 = xmm1[0,1],mem[0],xmm1[3]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 172], 48 # xmm1 = xmm1[0,1,2],mem[0]
	vmovss	xmm4, dword ptr [rsp + 4*rsi + 176] # xmm4 = mem[0],zero,zero,zero
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 180], 16 # xmm4 = xmm4[0],mem[0],xmm4[2,3]
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 184], 32 # xmm4 = xmm4[0,1],mem[0],xmm4[3]
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 188], 48 # xmm4 = xmm4[0,1,2],mem[0]
	vinsertf128	ymm1, ymm1, xmm4, 1
	vaddps	ymm1, ymm2, ymm1
	vcvtps2pd	ymm2, xmm1
	vextractf128	xmm1, ymm1, 1
	vcvtps2pd	ymm1, xmm1
	vmulpd	ymm1, ymm1, ymm10
	vmulpd	ymm2, ymm2, ymm10
	vcvtpd2ps	xmm2, ymm2
	vcvtpd2ps	xmm1, ymm1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1164], ymm0
	vinsertf128	ymm0, ymm2, xmm1, 1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1196], ymm0
	vpermilpd	xmm0, xmm3, 1   # xmm0 = xmm3[1,0]
	vmovups	ymm1, ymmword ptr [rsp + 4*rsi + 216]
	vblendps	ymm2, ymm3, ymm1, 1 # ymm2 = ymm1[0],ymm3[1,2,3,4,5,6,7]
	vpermps	ymm2, ymm8, ymm2
	vaddps	ymm2, ymm3, ymm2
	vinsertps	xmm0, xmm0, dword ptr [rsp + 4*rsi + 196], 16 # xmm0 = xmm0[0],mem[0],xmm0[2,3]
	vinsertps	xmm0, xmm0, dword ptr [rsp + 4*rsi + 200], 32 # xmm0 = xmm0[0,1],mem[0],xmm0[3]
	vinsertps	xmm0, xmm0, dword ptr [rsp + 4*rsi + 204], 48 # xmm0 = xmm0[0,1,2],mem[0]
	vmovss	xmm3, dword ptr [rsp + 4*rsi + 208] # xmm3 = mem[0],zero,zero,zero
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 212], 16 # xmm3 = xmm3[0],mem[0],xmm3[2,3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 216], 32 # xmm3 = xmm3[0,1],mem[0],xmm3[3]
	vinsertps	xmm3, xmm3, dword ptr [rsp + 4*rsi + 220], 48 # xmm3 = xmm3[0,1,2],mem[0]
	vinsertf128	ymm0, ymm0, xmm3, 1
	vaddps	ymm0, ymm2, ymm0
	vcvtps2pd	ymm2, xmm0
	vextractf128	xmm0, ymm0, 1
	vcvtps2pd	ymm0, xmm0
	vmulpd	ymm0, ymm0, ymm10
	vmulpd	ymm2, ymm2, ymm10
	vcvtpd2ps	xmm2, ymm2
	vcvtpd2ps	xmm0, ymm0
	vpermilpd	xmm4, xmm1, 1   # xmm4 = xmm1[1,0]
	vmovups	ymm3, ymmword ptr [rsp + 4*rsi + 248]
	vblendps	ymm5, ymm1, ymm3, 1 # ymm5 = ymm3[0],ymm1[1,2,3,4,5,6,7]
	vpermps	ymm5, ymm8, ymm5
	vaddps	ymm1, ymm1, ymm5
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 228], 16 # xmm4 = xmm4[0],mem[0],xmm4[2,3]
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 232], 32 # xmm4 = xmm4[0,1],mem[0],xmm4[3]
	vinsertps	xmm4, xmm4, dword ptr [rsp + 4*rsi + 236], 48 # xmm4 = xmm4[0,1,2],mem[0]
	vmovss	xmm5, dword ptr [rsp + 4*rsi + 240] # xmm5 = mem[0],zero,zero,zero
	vinsertps	xmm5, xmm5, dword ptr [rsp + 4*rsi + 244], 16 # xmm5 = xmm5[0],mem[0],xmm5[2,3]
	vinsertps	xmm5, xmm5, dword ptr [rsp + 4*rsi + 248], 32 # xmm5 = xmm5[0,1],mem[0],xmm5[3]
	vinsertps	xmm5, xmm5, dword ptr [rsp + 4*rsi + 252], 48 # xmm5 = xmm5[0,1,2],mem[0]
	vinsertf128	ymm4, ymm4, xmm5, 1
	vaddps	ymm1, ymm1, ymm4
	vcvtps2pd	ymm4, xmm1
	vinsertf128	ymm0, ymm2, xmm0, 1
	vextractf128	xmm1, ymm1, 1
	vcvtps2pd	ymm1, xmm1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1228], ymm0
	vmulpd	ymm0, ymm4, ymm10
	vcvtpd2ps	xmm0, ymm0
	vmulpd	ymm1, ymm1, ymm10
	vcvtpd2ps	xmm1, ymm1
	vinsertf128	ymm0, ymm0, xmm1, 1
	vextractf128	xmm1, ymm3, 1
	vblendps	xmm2, xmm3, xmm1, 1 # xmm2 = xmm1[0],xmm3[1,2,3]
	vpermilps	xmm2, xmm2, 57  # xmm2 = xmm2[1,2,3,0]
	vpermilps	xmm1, xmm1, 249 # xmm1 = xmm1[1,2,3,3]
	vinsertps	xmm1, xmm1, dword ptr [rsp + 4*rsi + 280], 48 # xmm1 = xmm1[0,1,2],mem[0]
	vinsertf128	ymm1, ymm2, xmm1, 1
	vpermilpd	xmm2, xmm3, 1   # xmm2 = xmm3[1,0]
	vaddps	ymm1, ymm3, ymm1
	vinsertps	xmm2, xmm2, dword ptr [rsp + 4*rsi + 260], 16 # xmm2 = xmm2[0],mem[0],xmm2[2,3]
	vinsertps	xmm2, xmm2, dword ptr [rsp + 4*rsi + 264], 32 # xmm2 = xmm2[0,1],mem[0],xmm2[3]
	vinsertps	xmm2, xmm2, dword ptr [rsp + 4*rsi + 268], 48 # xmm2 = xmm2[0,1,2],mem[0]
	vinsertf128	ymm2, ymm2, xmmword ptr [rsp + 4*rsi + 272], 1
	vaddps	ymm1, ymm1, ymm2
	vcvtps2pd	ymm2, xmm1
	vextractf128	xmm1, ymm1, 1
	vcvtps2pd	ymm1, xmm1
	vmulpd	ymm1, ymm1, ymm10
	vmulpd	ymm2, ymm2, ymm10
	vcvtpd2ps	xmm2, ymm2
	vcvtpd2ps	xmm1, ymm1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1260], ymm0
	vinsertf128	ymm0, ymm2, xmm1, 1
	vmovupd	ymmword ptr [rsp + 4*rsi + 1292], ymm0

Même pas l'excuse de l'alignement des vecteurs, aucun load n'est aligné.

[Tramb]

"Non mais en l'an ($MAINTENANT + un an) les compilateurs seront tellement balaises que y aura plus besoin d'optimiser soit même son code !"
(c) Des tas de mecs depuis 50 ans

Après tu lui fais mal avec ton 0.3333 au lieu de 0.3333f non ? (mais peut-être que tu fais effectivement du double, hein)

[Møgluglu]

Oui, au temps pour moi, j'ai vu les vcvt / vmulpd entre temps et j'ai corrigé (en vrai je suppose que la constante devrait être 1.f/3.f, mais le code original utilise une constante décimale à 5 chiffres. ). Le reste du code émis est toujours pareil.

Il y a sûrement quelqu'un qui doit être très fier de son analyse d'aliasing dans llvm qui identifie quand les loads de vecteurs se recouvrent partiellement, et de son optimisation qui remplace les loads vectoriels redondants par des simples permutations de registres vectoriels et loads scalaires.

Cela dit c'est toujours mieux que gcc. Les deux font aussi souvent de la merde, mais au moins avec llvm quand ça arrive on peut aller démêler les étapes d'analyse et de transformation et comprendre ce qui se passe.

[TiNitro]

"Non mais en l'an ($MAINTENANT + un an) les compilateurs seront tellement balaises que y aura plus besoin d'optimiser soit même son code !"
(c) Des tas de mecs depuis 50 ans

Ça reste vrai pour 99% des applications.
Pas le temps de citer les trouze mille exemples de mecs qui s'épuisaient à micro-optimiser pour des nèfles, parce que la complexité de leur bouzin était moisie....

[Møgluglu]

Mais c'est uniquement grâce aux machines qui sont extrêmement surdimensionnées par rapport aux besoins, pas aux compilateurs.

Tous les progrès héroïques de la recherche en compilation des 50 dernières années ont été annihilés instantanément par Python, Javascript et PHP.

[ducon]

Ben non, il faudra bien améliorer la compilation du code Python en bytecode et l’exécution du bytecode par un binaire compilé.

[Tramb]

Ça reste vrai pour 99% des applications.
Pas le temps de citer les trouze mille exemples de mecs qui s'épuisaient à micro-optimiser pour des nèfles, parce que la complexité de leur bouzin était moisie....

Bah ouais. Du coup les compilos gagneraient s'ils savaient changer les algorithmes !

- - - Mise à jour - - -

Ben non, il faudra bien améliorer la compilation du code Python en bytecode et l’exécution du bytecode par un binaire compilé.

Ça va être compliqué avec un "langage" pour lequel n'importe quel appel de fonction peut changer le __dict__.

[ducon]

Bah ouais. Du coup les compilos gagneraient s'ils savaient changer les algorithmes !

Utilise Fortran, optimisé avec amour depuis soixante ans.

[Mayalabielle]

Utilise Fortran, optimisé avec amour depuis soixante ans.

[Møgluglu]

Ben non, il faudra bien améliorer la compilation du code Python en bytecode et l’exécution du bytecode par un binaire compilé.

Un compilateur, ça sert à résoudre en pratique un problème qu'on a prouvé impossible à résoudre en théorie. On peut dire autant de mal qu'on veut des théoriciens, mais à un moment il faut bien admettre qu'ils ne disent pas que des conneries.

Utilise Fortran, optimisé avec amour depuis soixante ans.

Oui, Fortran ça poutre, et il a des concepts de folie gérés de base dans le langage, comme les tableaux multidimensionnels.
(En fait la communauté qui utilise Fortran s'est mise massivement à Python mais surtout pour remplacer leur code Matlab, pour les vrais codes c'est toujours Fortran, en concurrence avec C++.)

[William Vaurien]

A force de lire du code C de mon projet de vétérans des 90' (cf mes post d'il y a quelques mois ici), j'en arrive à trouver que des fois on se complique drôlement la vie en Java et que le (meta)code donne parfois la nausée, et que les préoccupations techniques viennent bien souvent empiéter sur les fonctionnalités.

Heureusement apès je tombe sur des bouts de code qui me rappel que de toujours faire au plus simple n'est pas non plus toujours une bonne idée:

for (imois = 1; imois <= 12; imois++) 
{
                if (imois == 1)  strcpy (moisC, "01");
		if (imois == 2)  strcpy (moisC, "02");
		if (imois == 3)  strcpy (moisC, "03");
		if (imois == 4)  strcpy (moisC, "04");
		if (imois == 5)  strcpy (moisC, "05");
		if (imois == 6)  strcpy (moisC, "06");
		if (imois == 7)  strcpy (moisC, "07");
		if (imois == 8)  strcpy (moisC, "08");
		if (imois == 9)  strcpy (moisC, "09");
		if (imois == 10) strcpy (moisC, "10");
		if (imois == 11) strcpy (moisC, "11");
		if (imois == 12) strcpy (moisC, "12");
...

Heureusement qu'il n'y a que douze mois!

Rien de bien méchant, mais ça reflète un code ultra KISS mais pas DRY... et qui en devient pénible à maintenir car chaque ligne 'business' est entouré par 10 lignes techniques...

[Tramb]

C'est quand même assez KISS.
Surtout le second S.