Anthony Jaguenaud a écrit 1939 commentaires

Je vais jeter un œil, j’ai ouvert la base en ligne de commande, et la base est bien faites…
Avec une table Élève, une table compétence, domaine, etc. Des joint-venture entre les tables.

Mais remixer ça à la main pour faire une nouvelle classe avec les compétences acquise l’année précédente ça va être plus compliqué !

Et faire un bel outil, risque de prendre du temps.

Je pensais plus à un outil qui prendrait un mot et qui donnerait une image… Avec des polices du genre [a—e] [a—p]… ce qui donnerait un premier jet.

Y-a-t-il des logiciels libres qui pourrait en créer plus ou moins automatiquement ?

Bon anniversaire et longue vie à Linuxfr.org.

En Haskell :

*Main> sqrt (-1)
NaN
*Main>

En Racket, une autre approche :

> (sqrt -1)
0+1i
>

Tu peux leurs dire qu’en fonction des langages, bibliothèques qui font les calculs, parfois ça balance des erreurs, parfois un nan comme dans le cas de numpy.
Leur expliquer que c’est un choix du langage, en c++ apparement, le langage remonte plutôt nan d’après ce site.

J’ai réussi en python en faisant ça…

Python 3.9.2 (default, Feb 28 2021, 17:03:44)
[GCC 10.2.1 20210110] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>> import math
>>> a = math.inf - math.inf
>>> print (a)
nan
>>>

Pas sûr que ce soit ce que veux l’auteur de la demande.

Effectivement :

import math

a = math.nan

print (a)

J’aurais pas parié ;-) mais c’est logique.

Il y a deux trois trucs qui me gène.

Se sont des ensembles, donc si tu as un ensemble de bonbon. Et un ensemble de nouriture au chocolat, un bonbon au chocolat sera dans les deux ensembles. C’est l’intersection.

Quand tu dis :

Si tu dis ∀x ∈ ℚ tel que x = 42, ∀y ∈ ℝ tel que y = 42 : en toute rigueur x ≠ y.

Non, en toute rigueur, x = y. En informatique, x ≠ y parce qu’ils n’ont pas le même type, mais pas en math. Tous les éléments de ℕ sont dans ℤ, tous les éléments de ℤ sont dans ℚ, tous les éléments de ℚ sont dans ℝ, mais se sont bien les mêmes éléments.

Autre chose :

par exemple on définit ℚ à partir de ℕ, ℝ à partir de ℚ

Bah non, plus. ℚ est défini à partir de ℤ. ℝ n’est pas défini à partir de ℚ, mais parce que certaines solutions à des équations n’ont pas de solutions de ℚ. Ex : x² = 2.

Tu parles des prises vampires ? Que de souvenir…

qqu'un ici a trouvé un job grâce à LinkedIn ?

Oui. À chaque fois sans vraiment chercher… un coup de mou, une offre qui passe qui à l’air sympas. Un coup de CV, pas de lettre de motivation, c’est eux qui cherche.

Je dirais entretient sur 50% des cas, soit 4 à tous cassé, et deux jobs : 2018 et 2021.

Parfois, il fallait passer par un utilitaire DOS pour modifier le port d’entré/sortie car ça ne se configurait pas sur cette saleté de Win95… alors que déjà à l’époque, on pouvait paramétrer le modprobe ne2k io=0x.... sous un certain OS ;-).

Tu peux ajouter le score de Zemmour à l'extrême droite. ce qui la fait monter autour de 30%, sauf si tu considères que Zemmour est autre chose que de l’extrême droite.

Oui, mais… sans Zemmour, Marine ne serait pas allée chercher les électeurs de Pécresse qui aurait de fait fait un meilleur score…
On peut refaire le match, mais c’est fini pour cinq ans.

Pour avoir un truc portable qui change rien entre Windows/Linux/BSD/etc. je pense qu’emacs est un bon candidat. En prime, vous pourrez gérer vos fichiers de la même manière sur tous les OS.
Il a également des tas de plugin.

La signification des codes de 1 à 254 est déterminée par le programme.

En fait, pas tout à fait. Il vaut mieux rester de 0 à 127. Sous Linux, généralement, si un processus est tué par un signal, tu retrouves le code de retour : 128 + numéro du signal.

capello:~$ cat >toto.c
int main()
{
while(1);
return 0;
}
capello:~$ gcc toto.c
capello:~$ ./a.out
^C
capello:~$ echo $?
130
capello:~$ kill -l
 1) SIGHUP       2) SIGINT       3) SIGQUIT      4) SIGILL       5) SIGTRAP
 6) SIGABRT      7) SIGBUS       8) SIGFPE       9) SIGKILL     10) SIGUSR1
11) SIGSEGV     12) SIGUSR2     13) SIGPIPE     14) SIGALRM     15) SIGTERM
16) SIGSTKFLT   17) SIGCHLD     18) SIGCONT     19) SIGSTOP     20) SIGTSTP
21) SIGTTIN     22) SIGTTOU     23) SIGURG      24) SIGXCPU     25) SIGXFSZ
26) SIGVTALRM   27) SIGPROF     28) SIGWINCH    29) SIGIO       30) SIGPWR
31) SIGSYS      34) SIGRTMIN    35) SIGRTMIN+1  36) SIGRTMIN+2  37) SIGRTMIN+3
38) SIGRTMIN+4  39) SIGRTMIN+5  40) SIGRTMIN+6  41) SIGRTMIN+7  42) SIGRTMIN+8
43) SIGRTMIN+9  44) SIGRTMIN+10 45) SIGRTMIN+11 46) SIGRTMIN+12 47) SIGRTMIN+13
48) SIGRTMIN+14 49) SIGRTMIN+15 50) SIGRTMAX-14 51) SIGRTMAX-13 52) SIGRTMAX-12
53) SIGRTMAX-11 54) SIGRTMAX-10 55) SIGRTMAX-9  56) SIGRTMAX-8  57) SIGRTMAX-7
58) SIGRTMAX-6  59) SIGRTMAX-5  60) SIGRTMAX-4  61) SIGRTMAX-3  62) SIGRTMAX-2
63) SIGRTMAX-1  64) SIGRTMAX
capello:~$

Ici, 130 == 128 + 2 => SIGINT qui correspond bien au <Ctrl>+c.

Édit: Arg, grillé !

Si tu ne mets pas les dépôts non-free sur debian, tu as aussi un système 100% libre, non ?

Je pense que le bug est dans ton cerveau ! Mais que faisais-tu sur le site de « closer » ?

Moi aussi, j’ai un CPU RGB… mais c’est juste parce que c’était le meilleur rapport qualité/prix… je l’ai découvert en l’allumant avant de fermer ma tour. C’est les araignées qui doivent être contentes.

Les exceptions constituent les erreurs non prévisibles, comme un problème réseau, disque plein, et d'autres aspects, comme la sécurité. Je comprends mal l'intérêt de ne pas utiliser les exceptions..

Je ne suis pas d’accord. Si les interfaces que tu utilises sont correctement définies, tu dois pouvoir connaître la liste des exceptions. Donc, des erreurs. Récupérer une exception networkUnreachable ou une erreur NetworkUnreachable, je ne vois pas trop la différence.

Le principal intérêt des exceptions, àmha, dans les langages impératifs, c’est de pouvoir balancer l’erreur et la récupérer à l’endroit le plus propice, sans faire de cascade d’erreur, de cas particulier juste dans l’optique de la rebalancer à l’appelant. Le pendant de ça, c’est que rien ne garantit que quelqu’un récupère l’erreur.

Avec les types permettant le Railway programming, dans les langages fonctionnels, si tu ajoutes un cas d’erreur, tous les case, match où le type est utilisé doit être complet. Donc le compilateur te le dira si tu oublies de gérer un cas d’erreur.

Programmer en langage c++ de Claude Delannoy.

Je ne sais pas si la dernière édition est bien, mais j’ai l’édition avec le C++ pré-c++2003 et je la trouve très bien, didactique, progressive.

La nouvelle édition traite jusqu’au c++17. Comme je suis un peu vieux, j’aime bien un livre… ça permet entre autres de lire un chapitre le soir avant de s’endormir. De s’en servir de référence sans avoir à switcher de fenêtre sur l’écran. De caler un écran ou un pied de table.

Le principe en F# de railway programming.

Le langage n’était pas vraiment interprété. Un programme était constitué d’une liste d’objets. Un objet pouvez être un nombre, une instruction, un programme.
Les 5 premiers quartets (2,5 octets) de l’objet étaient un pointeur vers le code assembleur gérant l’objet. Par exemple pour un nombre, c’était d’ajouter le nombre dans la pile. Pour un +, le code prend les deux nombres dans la pile, les ajoutes et recrée un objet de nombre dans la pile.
La fin du code assembleur d’un objet termine toujours par une instruction JUMP vers le pointeur de l’objet suivant.

Dans les objets faits par HP, il y en avait deux un peu spéciaux : begin et end qui permettait d’agréger des objets pour faire un truc de plus haut niveau. J’ai trouvé cette façon de faire vraiment très élégante.

Si la fonction est pure, soit sans effet de bord, recopier son code ou une référence revient au même.

Sur ma HP48, on pouvait manipuler le code directement dans la pile, manipuler l’ordre des éléments, les dupliquer, les évaluer, les concaténer, etc.

Dans tous les cas, il va rester le problème des variables globales et des effets de bord, qu’il y ait copie ou non.

En fait ta première ligne :((1-5) + 7 ) × 8 <=> ((7 - 5) + 1)×8. Solution que mon programme trouve. Il trouve également : (7-(5-1))×8.

Voilà la solution, j’ai changé les Int en Ratio Int, enlevé les vérifications de la division et de la soustraction (mais là, je n’en vois pas l’intérêt ;-) )

À chaque modification, j’ai laissé l’ancienne ligne en commentaire pour voir les différences.

import Data.List
-- new line
import Data.Ratio

-- A value is an Int or an operation with two arguments and a result.
--data Value = V Int | Op Operation Value Value Int
data Value = V (Ratio Int) | Op Operation Value Value (Ratio Int)
data Operation = Plus | Min | Mult | Div | Error

-- Instance of Show class to be able to display Operation type
instance Show Operation where
  show Plus = "+"
  show Min  = "-"
  show Mult = "×"
  show Div  = "÷"
  show _    = "Error"

-- Instance of Show class for Value.
instance Show Value where
--  show (V a) = show a
  show (V a) = show $ numerator a  -- The value is a % 1
  show (Op o a b _) = " (" ++ (show a) ++ (show o) ++ (show b) ++ ") "

-- Take an Operation and a list of 2 minimal Values. Generate a new value with the first two terms.
doOp :: Operation -> [Value] -> [Value]
doOp Plus (a:b:xs) = (Op Plus a b (va+vb):xs)
                      where va = getV a
                            vb = getV b
-- We don't want to have negative values, so check if a >= b
-- We work in ℚ
doOp Min (a:b:xs) = (Op Min a b ((getV a)-(getV b)):xs)
--                   | otherwise = (Op Error a b (-1)):xs
doOp Mult (a:b:xs) = (Op Mult a b (va*vb)):xs
                      where va = getV a
                            vb = getV b
-- First check that divisor is not 0, then check if b can divide a without rest.
doOp Div (a:b:xs) | vb == 0 = (Op Error a b (-1)):xs
--                  | va `mod` vb == 0 = (Op Div a b (va `div` vb)):xs
--                  | otherwise = (Op Error a b (-1)):xs
                  | otherwise = (Op Div a b (va / vb)):xs
                   where va = getV a
                         vb = getV b

-- Create a Ratio
--setV a = V a
setV a = V (a % 1)
getV (V a) = a
getV (Op _ _ _ a) = a


-- Do operations, take a list of Values and do all operations, drop error if a computation is not possible
doOps :: [Value] -> [[Value]]
doOps a = filter (dropError.head) $ map (\x -> doOp x a) [Plus, Min, Mult, Div] 

-- Check for error filter, return True if it's valid.
dropError :: Value -> Bool
dropError (Op Error _ _ _) = False
dropError _ = True

-- En entrée une liste de values, en sortie une liste d'opérations filtrée.
-- Check we have 4 numbers.
-- From right to left
--    - map setV x  => generate a Value list with only V values.
--    - compute all permutations
--    - For each list of values apply all operations on first two values, we get list of list of list so concat to obtain list of list Values
--    - We have 3 elements
--    - For each element, we perform permutations and concat to get a list of list of Values.
--    - loop twice to get list of list of Value with length == 1.
--    - Then filter to check if result is 24.
get24 :: [Int] -> [[Value]]
get24 x | length x == 4 = filter (\x -> (getV (head x))==24) $ concat.map doOps $ concat.map permutations $ concat.map doOps $ concat.map permutations $ concat.map doOps $ permutations $ map setV x
        | otherwise = []

Et le résultat :

*Main Data.Ratio> get24 [7,7,2,1]
[[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ]]
*Main Data.Ratio> get24 [ 1,4,5,6]
[[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ],[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ]]
*Main Data.Ratio> get24 [7,7,2,1]
[[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ],[ ( ( (7×7) -1) ÷2) ]]
*Main Data.Ratio> get24 [ 1,4,5,6]
[[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ],[ (6÷ ( (5÷4) -1) ) ],[ (4÷ (1- (5÷6) ) ) ]]

Oui, remplacer div par % et adapter les tests dans doOp Div (a:b:xs) :-)

Non, ça ne marchera pas.

:t (/)
(/) :: Fractional a => a -> a -> a
:t div
div :: Integral a => a -> a -> a
Prelude Data.Ratio> 1% 4
1 % 4
Prelude Data.Ratio> (1%4) `div` (4%5)

<interactive>:28:1: error:
    • Non type-variable argument in the constraint: Integral (Ratio a)
      (Use FlexibleContexts to permit this)
    • When checking the inferred type
        it :: forall a. (Integral a, Integral (Ratio a)) => Ratio a

La division entière à besoin d’un type integral ce que n'est pas Ratio. On ne peut pas mélanger les types dans les divisions.