initial commit

NSY104/25-01-09/A1M1S1P3 - numeration_base/diapos5.py

@@ -0,0 +1,13 @@
+#!/usr/bin/python3
+
+nbDecimal = int(input("Donner un nombre entier à convertir en binaire : "))
+nbBinaire = []
+
+tmp = nbDecimal
+
+while tmp != 0:
+    reste = tmp % 2
+    nbBinaire.append(reste)
+    tmp = tmp // 2
+nbBinaire.reverse()
+print("({})b10 = ({})b2".format(nbDecimal, nbBinaire))

NSY104/25-01-09/A1M1S1P3 - numeration_base/diapos5.py~

@@ -0,0 +1,11 @@
+nbDecimal = int(input("Donner un nombre entier à convertir en binaire : "))
+nbBinaire = []
+
+tmp = nbDecimal
+
+while tmp != 0:
+    reste = tmp % 2
+    nbBinaire.append(reste)
+    tmp = tmp // 2
+nbBinaire.reverse()
+print("({})b10 = ({})b2".format(nbDecimal, nbBinaire))

NSY104/25-01-09/A1M1S1P3 - numeration_base/fracTobin.py

@@ -0,0 +1,15 @@
+#!/usr/bin/python3
+
+''' conversion partie fractionnaire d'un nombre décimal en binaire '''
+
+def calcul(nbDec):
+    digit = []
+    while nbDec != 0:
+        nbDec *= 2
+        digit.append((int(nbDec)))
+        nbDec = nbDec - int(nbDec)
+    return digit            
+
+if __name__ == '__main__':
+    nbDec = float(input("Donner le nombre décimal à convertir : "))
+    print(calcul(nbDec))

NSY104/25-01-09/A1M1S1P3 - numeration_base/fracTobin.py~

@@ -0,0 +1,15 @@
+#!/usr/bin/python3
+
+''' conversion partie fractionnaire d'un nombre décimal en binaire '''
+
+def calcul(nbDec):
+    digit = []
+    while nbDec != 0:
+        nbDec *= 2
+        digit.append((int(nbDec)))
+        nbDec = nbDec - int(nbDec)
+    return digit            
+
+if __name__ == '__main__':
+nbDec = float(input("Donner le nombre décimal à convertir : "))
+print(calcul(nbDec))

NSY104/25-01-09/A1M1S1P3 - numeration_base/fracTobin2.py

@@ -0,0 +1,15 @@
+#!/usr/bin/python3
+
+''' conversion partie fractionnaire d'un nombre décimal en binaire '''
+
+def calcul(nbDec):
+    digit = []
+    while nbDec != 0:
+        nbDec *= 2
+        digit.append((int(nbDec)))
+        nbDec = nbDec - int(nbDec)
+    return digit            
+
+if __name__ == '__main__':
+    nbDec = float(input("Donner le nombre décimal à convertir : "))
+    print(calcul(nbDec))

NSY104/25-01-09/A1M1S1P3 - numeration_base/fracTobin2.py~

@@ -0,0 +1,15 @@
+#!/usr/bin/python3
+
+''' conversion partie fractionnaire d'un nombre décimal en binaire '''
+
+def calcul(nbDec):
+    digit = []
+    while nbDec != 0:
+        nbDec *= 2
+        digit.append((int(nbDec)))
+        nbDec = nbDec - int(nbDec)
+    return digit            
+
+if __name__ == '__main__':
+    nbDec = float(input("Donner le nombre décimal à convertir : "))
+    print(calcul(nbDec))

NSY104/25-01-09/A1M1S1P3 - numeration_base/fracTobin3.py

@@ -0,0 +1,16 @@
+#!/usr/bin/python3
+
+''' conversion partie fractionnaire d'un nombre décimal en binaire '''
+
+def calcul(nbDec):
+    digit = []
+    nbDec = nbDec - int(nbDec)
+    while nbDec != 0:
+        nbDec *= 2
+        digit.append((int(nbDec)))
+        nbDec = nbDec - int(nbDec)
+    return digit            
+
+if __name__ == '__main__':
+    nbDec = float(input("Donner le nombre décimal à convertir : "))
+    print(calcul(nbDec))

NSY104/25-01-09/README.md

@@ -0,0 +1,73 @@
+# NSY104 09 01 2025
+
+> Le Module est un 100% parcielle, il n'y a pas e devoir maison.
+
+## Numération de base
+
+### Addition Binaire :
+
+01101+10111 = 100100
+
+### Soustraction Binaire :
+
+1101110-10111 = 1010111
+
+Voir des video car le prof explique ... commme à son habitude.
+
+### Exercice :
+
+#### 2.1 : 
+
+397 = 110001101
+133 = 10000101
+110 = 1101110
+
+101 = 5
+0101 = 5
+1101110 = 110
+
+#### 2.2
+
+a) 1100+1000 =
+
+        1100
+       +1000
+       ------
+       10100    
+
+b) 1001+1011 =
+
+        1001
+       +1011
+       ------
+       10100
+
+c) 1100-1000 =
+
+        1100
+       -1000
+       ------
+        0100
+
+d) 1000-101 =
+
+        1000
+       - 101
+       ------
+        0011
+
+e) 1+1+1+1 = 
+
+           1           1           10
+        +  1   ->   +  1   ->   +  10
+        ----        ----         ----
+          10          10          100
+
+#### 2.3
+
+a) 1011*11
+
+        1011
+        * 11
+        ----
+            

NSY104/25-02-18/A1M1S1P5_Representation_des_nombres/Depassement.java

@@ -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 );
+		}
+	}
+}

NSY104/25-02-18/A1M1S1P5_Representation_des_nombres/Imprecision.java

@@ -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

NSY104/25-02-18/A1M1S1P5_Representation_des_nombres/compa2.py

@@ -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)

NSY104/25-02-18/A1M1S1P5_Representation_des_nombres/dec2bins-komo.py

@@ -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)

NSY104/25-02-18/A1M1S1P5_Representation_des_nombres/overflow.c

@@ -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;
+
+
+      
+       }

NSY104/25-02-18/README.md

@@ -0,0 +1,4 @@
+# NSY104 18 02 2025
+
+>Reprise du cours du 09/01/2025
+

NSY104/25-03-04/README.md

@@ -0,0 +1,6 @@
+# NSY104-04-03-25
+
+Reprise "Représentation des nombres"
+
+C'est sur à l'examen
+

NSY104/25-05-21/README.md

@@ -0,0 +1,2 @@
+# NSY 104 21 05 2025
+

NSY104/25-05-23/README.md

@@ -0,0 +1,133 @@
+# NSY104-23-05-2025
+
+## Créer un raid 5 :
+
+### Installation du packet mdadm :
+
+```
+apt install mdadm
+```
+
+### création des partitions :
+
+```
+cfdisk /dev/sdb
+```
+> -> gpt -> New -> Type -> Linux RAID -> Whrite -> Yes
+```
+cfdisk /dev/sdc
+```
+> -> gpt -> New -> Type -> Linux RAID -> Whrite -> Yes
+```
+cfdisk /dev/sdd
+```
+> -> gpt -> New -> Type -> Linux RAID -> Whrite -> Yes
+```
+cfdisk /dev/sde
+```
+> -> gpt -> New -> Type -> Linux RAID -> Whrite -> Yes
+
+### Création du RAID5 avec mdadm :
+
+```
+mdadm --create /dev/md0 --level=raid5 --raid-devices=3 /dev/sdb1 /dev/sdc1 /dev/sdd1 --spare-device=1 /dev/sde1
+```
+
+### Sauvegarde de configuration de la matrice :
+```
+mkfs -t ext4 /dev/md0
+```
+`en root :`
+```
+echo "DEVICE partitions" > /etc/mdadm/mdadm.conf
+mdadm --detail --scan >> /etc/mdadm/mdadm.conf
+```
+### Montage du RAID5 :
+```
+mount /dev/md0 /mnt
+```
+
+### Pour voir les info :
+```
+cat /proc/mdstat
+mdadm --detail /dev/md0
+```
+### Pour simuler une pan :
+```
+mdadm /dev/md0 -f /dev/sdc1
+```
+### Force L'arrêt du disque dans le RAID5
+```
+mdadm /dev/md0 --fail /dev/sdc1
+```
+### Supprimer un disque du RAID5
+```
+mdadm /dev/md0 --remove /dev/sdc1
+```
+### Supprimer les informations d'appartenance du disque
+```
+mdadm --zero-superblock /dev/sdc1
+```
+### Ajouter un disque au RAID5 :
+```
+mdadm /dev/md0 -a /dev/sdc1
+```
+### Arrêter la matrice :
+```
+unmount /mnt
+mdadm --stop /dev/md0 
+```
+
+mdadm --zero-superblock /dev/sdb1
+mdadm --zero-superblock /dev/sdc1
+
+## Pour créer un un LVM et suite du TP
+
+apt install lvm2
+
+```
+cfdisk /dev/sdb
+```
+> -> gpt -> New -> Type -> Linux LVM -> Whrite -> Yes
+```
+cfdisk /dev/sdc
+```
+> -> gpt -> New -> Type -> Linux LVM -> Whrite -> Yes
+
+fdisk -l /dev/sdb
+
+fdisk -l /dev/sdc
+
+pvcreate /dev/sdb1
+
+pvdisplay /dev/sdb1
+
+
+vgcreate vg01 /dev/sdb1
+
+vgdisplay vg01
+
+lvcreate -n data01 -L 512 vg01
+ls /dev/vg01/data01
+
+lvdeisplay -m /dev/vg01/data01
+
+
+
+mkfs -t ext4 /dev/vg01/data01
+
+mkdir /mnt/data01
+mount /dev/vg01/data01 /mnt/data01
+
+lvcreate -n data02 -L 512m vg01
+lvdisplay -m /dev/vg01/data02
+
+mkfs -t ext4 /dev/vg01/data02
+
+mkdir /mnt/data02
+mount /dev/vg01/data02 /mnt/data02
+
+1 : Question de cour représentation de informations - 6 points
+2 : Machine de turing - 4 points
+3 : Fonctionnement d'une unité central - 4 points
+4 : QCM 6 points

NSY104/25-06-10/README.md

@@ -0,0 +1,2 @@
+# NSY104 10 06 2025
+

NSY104/README.md

@@ -0,0 +1,5 @@
+# NSY 104 Architecture des systèmes informatiques
+
+* [09/01/25](./NSY104-09-01-25)
+* [18/02/25](./NSY104-18-02-25)
+* [04/03/25](./NSY104-04-03-25)