J'ai fais du câblage horizontal avec mon père, mais uniquement dans le salon.

J'vais devoir d'ailleurs péter à nouveau le mur de l'escalier pour ajouter deux prises en plus.

J'vais aussi installer une armoire de brassage à la cave.

J'ferais des photos une fois que c'est opérationnel

Ahok

Tain je comprends pas,

http://pastebin.com/2pZ7zWgS

J'ai amélioré mon programme mais il surcharge toujours la RAM, je suis monté à 3go d'utilisation du coup il a crashé. Mais pourtant je devrais pas en utiliser autant,

C'est cette fonction

combinationsPoly :: Int -> PolyInt -> Integer -> Integer -> [[Integer]]
combinationsPoly x poly prod sumr = uniq $ map (sort) $ combRacines
where testRac racines = product racines == prod && sum racines == sumr
combRacines = [ racine | racine<-ensRacines , testRac racine ]
ensRacines = replicateM x poly

Normalement il devrait jeter toutes les listes qui ne satisfont pas le prédicat testRac, sauf que même comme ça je surcharge la mémoire. Mais bon faut dire que même s'il n'y a qu'un seul emsemble de racines la fonction replicateM va tester tout les arrangements possibles. Du coup avec n le degré de mon polynôme j'ai n! arrangements donc avec un polynôme de degré 9 j'ai 362880 arrangements Ca fait beaucoup je pense, il faudrait pouvoir jeter directement toutes les listes égales à une autre liste à un arrangement près mais je vois pas comment faire si quelqu'un à une idée

C'est bon je viens de résoudre le problème, 0 utilisation mémoire

J'ai mis 5min à résoudre un poly degré 7, sachant qu'on met 2x plus de temps à chaque fois je vais tenter de résoudre un poly degré 20 dans un screen.

la réponse demain

Bon okay j'ai fait un petit peu trop le malin, on va commencer avec un degré 11

Ça sent le stack overflow

J'avoue la fonction qui a résolu le problème vient de stack overflow J'ai pas encore le niveau pour faire un truc comme ça

Un haskeller pour me dire si avec la paresse la récursivité terminale est encore importante en Haskell (enfin si c’est exploité quoi)

Récursivité terminale? Tu parles du cas de base?

Jamy http://fr.wikipedia.org/w/wiki/R%C3%A9cursion_terminale

Je t’invite à aller voir la page anglaise qui doit être plus complète même si je ne l’ai pas lue

En gros le fait de faire ça permet de faire des simplification dans le code généré c'est ça?

Vu la page en anglais j'imagine que oui

En OCaml en tout cas c’est directement traduit en boucle for dans le bytecode généré

Après certains diront que le fait de coder en continuation rend le code illisible, mais en OCaml je trouve cela plus clair

Le code généré par ghc est illisible (ça change de gcc) je trouve enfin c'est vraiment le bordel donc ce sera difficile à voir je pense. Mais ça me parait logique qu'une telle simplification soit importante.

Mais je l'utilise pas trop je trouve,

par exemple pour la fonction factorielle

factorial 0 = 1
factorial x = x * factorial (x-1)

C'est pas une récursivité terminale j'imagine vu que je multiplie par x mais bon d'un côté en implémentation naive je vois pas d'autres solutions

fac n = aux 1 n where aux k 0 = k; aux k m = aux (k*m) (m-1)

Par exemple (je connais pas les conventions de mise en forme en haskell)

Mais ça a pas l’air de faire une grande différence en vrai

fac n = aux 1 n
where aux k 0 = k
aux k m = aux (k*m)(m-1)

En Haskell

Temps d'execution de factorial 7777 avec ta fonction 0.025s et avec la mienne 0.021s

Dans ton cul la récursivité terminale

Le code source est là

Naif: http://redcloud.fr/naif.s
Chouhartem: http://redcloud.fr/chouhartem.s

Je rage

Mais sérieux l'assembleur qui sort de ghc est illisible

En Ocaml ton implémentation est plus rapide?

Oui, et surtout ne stack overflow pas