initial commit

2026-05-26 13:56:03 +02:00
parent 4c720637a1
commit ff4bb12d22
539 changed files with 12415 additions and 0 deletions
@@ -0,0 +1,36 @@
+/*
+Ce programme initialise la variable n à 10, et l’élève au carré plusieurs fois. Les valeurs
+affichées devraient donc être toutes des puissances de 10, mais en exécutant le programme,
+vous verrez que ce n’est pas le cas pour les dernières valeurs, qui sont trop grandes pour
+être représentées correctement par le type int. Vous pouvez également changer le type de
+n de int à long et short pour voir l’impact sur les valeurs calculées.
+Soyez donc vigilants quand votre programme doit travailler avec de grandes valeurs !
+
+Les entiers :
+byte : 1 octet de – 128 à 127
+short : 2 octets de – 32 768 à 32 767
+int : 4 octets de – 2 147 483 648 à 2 147 483 647
+long : 8 octets de – 9 223 372 036 854 775 808 à 9 223 372 036 854 775 807
+
+Les réels :
+float : 4 octets de 1.40239846e-45F à 3.402823347e38F
+double : 8 octets de 4.94065645841246544e-324D à 1.79769313486231570e308D
+
+Note : Pour utiliser les valeurs limites en Java, on peut utiliser les constantes suivantes :
+- Integer.MAX_VALUE
+- Double.MAX_VALUE
+
+*/
+
+
+public class Depassement {
+
+	public static void main(String[] args) {
+		int n = 10;
+		System.out.println( n );
+		for (int i = 0; i < 5; i++){
+			n = n * n;
+			System.out.println( n );
+		}
+	}
+}
@@ -0,0 +1,56 @@
+
+
+public class Imprecision {
+	public static void main(String[] args) {
+		test1();
+		test2();
+		test3();
+
+	}//main
+
+static void test1(){
+
+/*Si le type double pouvait représenter parfaitement les valeurs réelles, ce programme
+afficherait 0. Or, sur mon ordinateur, j’obtiens environ la valeur 7.10E−15 , qui est une valeur
+très petite mais pas nulle. C’est parce que la variable racine ne peut stocker exactement
+la racine de a, et donc l’expression racine * racine ne vaut pas exactement a.
+*/
+
+
+	double a = 37.0;
+	double racine = Math.sqrt(a);
+	System.out.println("test1 : " + (a - racine * racine) );
+}//test1
+
+static void test2(){
+
+/*C’est pour ça que les tests d’égalité ou d’inégalité entre double (ou float) NE DEVRAIENT PAS ÊTRE utilisés.
+Par exemple, le code suivant, n’affiche rien, contrairement à ce qu’on pourrait s’attendre.
+*/
+
+	double a = 37.0;
+	double racine = Math.sqrt(a);
+	if (a == racine * racine) {
+		System.out.println( "test2 : ok" );
+	}
+	else System.out.println("test2 : pas ok !");
+}//test2
+
+static void test3(){
+
+/*Si vous devez absolument comparer des valeurs de type double vous pouvez utiliser un test tel que celui-ci :*/
+
+	double a = 37.0;
+	double racine = Math.sqrt(a);
+	double epsilon = 7.105427357601003E-15; // test1() donne pour (a - racine * racine) = 7.105427357601002E-15
+	if (Math.abs(a - racine * racine) < epsilon) {
+		System.out.println( "test3 : ok" );
+	}
+
+/*où epsilon est une très petite valeur et abs calcule la valeur absolue. Cette valeur de-
+vrait être choisie selon la précision du type utilisé, mais comment déterminer cette valeur
+idéalement sort largement du cadre de ce cours.*/
+
+}//test3
+
+}//class
@@ -0,0 +1,25 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+def twos_comp(val, bits):
+    """compute the 2's compliment of int value val"""
+    if( (val&(1<<(bits-1))) != 0 ):
+        val = val - (1<<bits)
+    return val
+
+
+binary_string = '1111' # or whatever... no '0b' prefix
+out = twos_comp(int(binary_string,2), len(binary_string))
+print(out)
+
+hex_string = '0xFFFFFFFF' # or whatever... '0x' prefix doesn't matter
+out = twos_comp(int(hex_string,16), 32)
+print(out)
+
+overflow = bin(129) # en binaire = 0b1000001 et en hexa = 0x81
+out = twos_comp(int(overflow,2), 8)
+print(out)
+
+overflow = bin(4294967292) # en binaire = 0b11111111111111111111111111111100 et en hexa = 0xfffffffc
+out = twos_comp(int(overflow,2), 32)
+print(out)
@@ -0,0 +1,49 @@
+#!/usr/bin/python
+# -*- coding: utf-8 -*-
+
+
+def dec2bin(d,nb=0):
+    """dec2bin(d,nb=0): conversion nombre entier positif ou nul -> chaîne binaire (si nb>0, complète à gauche par des zéros)"""
+    if d==0:
+        b="0"
+    else:
+        b=""
+        while d!=0:
+            b="01"[d&1]+b
+            d=d>>1
+    return b.zfill(nb)
+ 
+
+
+def dec2bins(d,nb=0):
+    """dec2bins(d,nb=0): conversion nombre entier signé d -> chaîne binaire pour un mot de nb bits (=0 par defaut) """
+    # calcul de la taille mini du mot permettant de représenter la valeur signée d (signe compris)
+    n=1
+    if d>=0:
+        x=d
+    else:
+        x=-d-1
+    while (1<<n)<=x:
+        n+=1
+    n+=1
+    # valeur de nb à prendre pour la suite des calculs (si nb<n, le nb donné est trop faible pour le d donné)
+    if (nb==0) or (nb<n):
+        nb=n
+    # calculs
+    if d>=0:
+        # on renvoie la chaîne normale, complétée par des "0" à gauche et par le bit de signe = "0"
+        b='0' + dec2bin(d,nb-1)
+    else:
+        # on renvoie la chaîne signée, complétée par des "1" à gauche et par le bit de signe "1"
+        b='1' + dec2bin((1<<(nb-1))+d,(nb-1))
+    return b
+ 
+# Exemple d'utilisation:
+#print dec2bins(4294967292,32)
+
+
+#komo
+
+entier = int(input('Donner le nombre entier à convertir : '))
+form =  int(input('Donner le format de conversion : '))
+print dec2bins(entier,form)
@@ -0,0 +1,70 @@
+#include <stdio.h>
+
+/*On peut consulter le fichier /usr/include/limits.h pour connaître les valeurs limites des différents types.
+
+
+Type             Occupation mémoire               Plage de valeur
+
+char             1 octet                         –128 to 127
+
+int              2 à 4 octets                    
+		         selon implémentation                                    
+
+short            2 octet                         –32,768 to 32,767
+
+long             4 octet                         –2,147,483,648 to 2,147,483,647
+
+unsigned char    1 octet                         0 to 255
+
+unsigned int     2 à 4 octets 
+                 selon implémentation                   
+
+unsigned short   2 octet                         0 to 65,535
+
+unsigned long    4 octet                         0 to 4,294,967,295
+
+float            4 octet                         ±3.4 x 10e38 to ±3.4 x 10e–38
+
+double           8 octet                         ±1.7 x 10e–308 to ±1.7 x 10e308
+
+long double      10 octet                        ±3.4 x 10e–4932 to ±3.4 x 10e4932
+ 
+*/
+int main(){
+       int entier = 4294967292;
+       int entier2 = 129; // sur 4 octets de 0 a 2147483647 et de -1 a -2147483648
+       char car = 'A'; //sur un octet de 0 a 127 et de -1 a -128
+      
+       printf(" taille car= %d\n", sizeof( car ));
+       printf(" taille short = %d\n", sizeof( short ));
+       printf(" taille unsigned short = %d\n", sizeof( unsigned short ));
+       printf(" taille int = %d\n", sizeof( int ));
+       printf(" taille unsigned int = %d\n", sizeof( unsigned int ));
+       printf(" taille long int = %d\n", sizeof( long int ));
+       printf(" taille unsigned long int = %d\n", sizeof( unsigned long int ));
+       printf(" taille long long int = %d\n", sizeof( long long int ));
+       printf(" taille unsigned long long int = %d\n", sizeof( unsigned long long int ));
+       
+       printf("4 et 4294967292    en tant que nombre sans signe : %u %u\n", 4, entier);
+       printf("4 et 4294967292    en tant que nombre avec signe : %d %d\n", 4, entier); 
+
+/* 
+4294967292 -> 11111111111111111111111111111100
+complément à 2 : 00000000000000000000000000000011 + 1 = 00000000000000000000000000000100 -> -4
+*/       
+     
+       
+       /*entier2 = car;
+       printf("entier = %d\n", entier);*/
+       
+       car = entier2;
+       printf("car = %d\n", car);
+
+//       printf("A = %x\n", car); //en hexa
+//     printf("A = %d\n", car); //en decimal
+
+return 0;
+
+
+      
+       }