Nombres entiers

Les équations sur ce site sont affichées avec MathJax.

Quelques articles de sources externes :

Dix manières différentes de vérifier si un entier est une puissance de deux en langage C, par Rick Regan en 2009 : http://www.exploringbinary.com/ten-ways-to-check-if-an-integer-is-a-power-of-two-in-c/
Convertir d'une représentation à virgule flottante à une représentation décimale à l'aide de gros entiers, texte de Rick Regan en 2011 : http://www.exploringbinary.com/correct-decimal-to-floating-point-using-big-integers/ (pour une version plus rapide : http://www.exploringbinary.com/fast-path-decimal-to-floating-point-conversion/)
Pourquoi les ordinateurs représentent-ils les entiers à partir du complément à deux? Texte d'Igor Ostrovsky en 2010 : http://igoro.com/archive/why-computers-represent-signed-integers-using-twos-complement/
Remplacer des nombres à virgule flottante par des entiers en les changeant d'échelle, par Danny Kalev en 2007 : http://www.informit.com/guides/content.aspx?g=cplusplus&seqNum=355
Considérations de division entière :
- accélérer la division sur des entiers non-signés lorsque le dénominateur est une constante :
  - texte de 2005 : http://blogs.msdn.com/b/devdev/archive/2005/12/12/502980.aspx
  - par Cory Doras en 2011 : http://ridiculousfish.com/blog/posts/labor-of-division-episode-iii.html
- dans ce texte de 2013, John Regher montre que même les compilateurs récents gèrent mal certains cas comme la division d'INT_MIN par -1, du moins lorsque les niveaux d'optimisation appliqués sont élevés : http://blog.regehr.org/archives/887
- une division entière qui arrondit « vers le haut », par Eric Lippert en, dans un article qui discute de la nuance entre considérer que $\frac{-5}{2}=-3$ reste $1$ ou encore que $\frac{-5}{2}=-2$ reste $-1$ , un problème que les langages tendent à régler par décret : http://ericlippert.com/2013/01/28/integer-division-that-rounds-up/
- dans certains langages, dontet J, l'expression $\frac{0}{0}$ vaut $0$ . Cet article de E. E. McDonnell explique pourquoi : http://www.jsoftware.com/papers/zero.htm
En 2011, John Regehr explique comment, selon lui, les opérations sur des entiers devraient fonctionner dans un langage de programmation système : http://blog.regehr.org/archives/642
Texte de 2012 par John Carlos Baez sur des entiers absolument énormes : http://johncarlosbaez.wordpress.com/2012/04/24/enormous-integers/
Définir une relation d'équivalence entre deux entiers, et les aléas de la valeur absolue. Texte d'Andrew Koenig en 2013 : http://www.drdobbs.com/cpp/if-c-objects-are-unrelated-are-they-equa/240146950
En 2016, Daniel Lemire liste les opérations réversibles sur les entiers, à sa connaissance : http://lemire.me/blog/2016/08/09/how-many-reversible-integer-operations-do-you-know/
Artihmétique et C# :
- construire l'arithmétique des entiers naturels () par programmation en C# à l'aide des seuls types object et bool, un exercice de style (inspiré de l'arithmétique de Peano) par Eric Lippert en 2013 :
- article « pour débutants » portant sur les périls de l'arithmétique avec C#, par Eric Lippert en 2014 : hthttp://devproconnections.com/development/c-sharp-code-writing-tips-eric-lippert-math
- pourquoi la division d'un int par un long donne-t-elle un long plutôt qu'un int?
  - texte d'Eric Lippert en 2009 : http://ericlippert.com/2009/01/28/long-division/
  - texte d'Eric Lippert en 2015 : http://ericlippert.com/2015/04/20/long-division-part-two/

Entiers et débordements, une situation pour le moins inconfortable qui peut mener à du Undefined Behavior :

Gérer les débordements lors de calculs sur des entiers en C, par Felix von Leitner en 2007 : http://www.fefe.de/intof.html
Quelques risques de la programmation en C avec des entiers, mis en relief par Glennan Carnie dans un texte de 2014 : http://blog.feabhas.com/2014/10/vulnerabilities-in-c-when-integers-go-bad/
Gérer les débordements dans les opérations appliquées sur des entiers, texte de Forrest Smith en 2014 avec accent sur la programmation avec C++ : http://forrestthewoods.ghost.io/perfect-prevention-of-int-overflows/
Selon John Regehr en 2014, le matériel devrait générer une « trappe » lors d'un débordement sur un entier : http://blog.regehr.org/archives/1154
Réflexion de Patrick Walton en 2014 sur la possibilité – et sur les conséquences potentielles – d'ajouter la détection automatique des débordements lors d'opérations sur des entiers à Rust : https://mail.mozilla.org/pipermail/rust-dev/2014-June/010494.html
Quel est le coût réel de tester systématiquement les débordements lors de calculs sur des entiers?
- texte de Dan Luu en 2014 : http://danluu.com/integer-overflow/
- commentaire de John Regehr en 2014 : https://plus.google.com/105487075784331805819/posts/dyKKLrW8jXb
Court texte de 2014 qui rappelle que la soustraction d'entiers n'est pas (du moins, pas dans le cas général) une comparaison : http://www.tedunangst.com/flak/post/subtraction-is-not-comparison
Combien vaut -1u en C++? La réponse n'est pas simple, comme le rappelle Jonathan Adamczewski en 2015 : http://brnz.org/hbr/?p=1433
Détecter les débordements en C++ à l'aide de templates, par Kenton Varda en 2015 : https://capnproto.org/news/2015-03-02-security-advisory-and-integer-overflow-protection.html
Ce qui fait que $A+B \ne A-(-B)$ , un texte de 2009 par Andrey Karpov qu'il est sain de lire et de comprendre : http://www.viva64.com/en/b/0039/
Profiter des débordements pour réaliser certaines optimisations, par Raymond Chen en 2015 : https://blogs.msdn.microsoft.com/oldnewthing/20151214-00/?p=92621
Texte de 2016 par Krister Walfridsson qui explore les optimisations que parvient à faire gcc devant des cas de débordement sur des entiers signés : http://kristerw.blogspot.ca/2016/02/how-undefined-signed-overflow-enables.html
En 2016, Marco Foco discute du comportement indéfini lors de débordements sur des entiers : http://marcofoco.com/?p=137
Les conséquences d'un débordement (même en Ada) peuvent être dramatiques, comme le rappelle cet article d'Aleksey Statsenko en 2016 : http://www.viva64.com/en/b/0426/
En 2016, John Regher discute de solutions au problème des débordements : http://blog.regehr.org/archives/1401

Compléments historiques :

L'algorithme de Karatsuba, pour multiplier de gros entiers : http://en.wikipedia.org/wiki/Karatsuba_algorithm