Deprecated: Using ${var} in strings is deprecated, use {$var} instead in /home/lestanvi/wiki/includes/GlobalFunctions.php on line 1978

Deprecated: Return type of MediaWiki\Session\PHPSessionHandler::open($save_path, $session_name) should either be compatible with SessionHandlerInterface::open(string $path, string $name): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/PHPSessionHandler.php on line 181

Deprecated: Return type of MediaWiki\Session\PHPSessionHandler::close() should either be compatible with SessionHandlerInterface::close(): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/PHPSessionHandler.php on line 196

Deprecated: Return type of MediaWiki\Session\PHPSessionHandler::read($id) should either be compatible with SessionHandlerInterface::read(string $id): string|false, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/PHPSessionHandler.php on line 210

Deprecated: Return type of MediaWiki\Session\PHPSessionHandler::write($id, $dataStr) should either be compatible with SessionHandlerInterface::write(string $id, string $data): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/PHPSessionHandler.php on line 238

Deprecated: Return type of MediaWiki\Session\PHPSessionHandler::destroy($id) should either be compatible with SessionHandlerInterface::destroy(string $id): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/PHPSessionHandler.php on line 344

Deprecated: Return type of MediaWiki\Session\PHPSessionHandler::gc($maxlifetime) should either be compatible with SessionHandlerInterface::gc(int $max_lifetime): int|false, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/PHPSessionHandler.php on line 365

Deprecated: strcasecmp(): Passing null to parameter #1 ($string1) of type string is deprecated in /home/lestanvi/wiki/includes/session/CookieSessionProvider.php on line 101

Deprecated: Return type of MediaWiki\Session\Session::count() should either be compatible with Countable::count(): int, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 588

Deprecated: Return type of MediaWiki\Session\Session::current() should either be compatible with Iterator::current(): mixed, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 594

Deprecated: Return type of MediaWiki\Session\Session::next() should either be compatible with Iterator::next(): void, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 606

Deprecated: Return type of MediaWiki\Session\Session::key() should either be compatible with Iterator::key(): mixed, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 600

Deprecated: Return type of MediaWiki\Session\Session::valid() should either be compatible with Iterator::valid(): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 618

Deprecated: Return type of MediaWiki\Session\Session::rewind() should either be compatible with Iterator::rewind(): void, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 612

Deprecated: Return type of MediaWiki\Session\Session::offsetExists($offset) should either be compatible with ArrayAccess::offsetExists(mixed $offset): bool, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 628

Deprecated: Return type of & MediaWiki\Session\Session::offsetGet($offset) should either be compatible with ArrayAccess::offsetGet(mixed $offset): mixed, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 641

Deprecated: Return type of MediaWiki\Session\Session::offsetSet($offset, $value) should either be compatible with ArrayAccess::offsetSet(mixed $offset, mixed $value): void, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 651

Deprecated: Return type of MediaWiki\Session\Session::offsetUnset($offset) should either be compatible with ArrayAccess::offsetUnset(mixed $offset): void, or the #[\ReturnTypeWillChange] attribute should be used to temporarily suppress the notice in /home/lestanvi/wiki/includes/session/Session.php on line 656

Deprecated: Message implements the Serializable interface, which is deprecated. Implement __serialize() and __unserialize() instead (or in addition, if support for old PHP versions is necessary) in /home/lestanvi/wiki/includes/language/Message.php on line 136

Deprecated: MapCacheLRU implements the Serializable interface, which is deprecated. Implement __serialize() and __unserialize() instead (or in addition, if support for old PHP versions is necessary) in /home/lestanvi/wiki/includes/libs/MapCacheLRU.php on line 37

Warning: Cannot modify header information - headers already sent by (output started at /home/lestanvi/wiki/includes/session/Session.php:48) in /home/lestanvi/wiki/includes/changes/ChannelFeed.php on line 95

Warning: Cannot modify header information - headers already sent by (output started at /home/lestanvi/wiki/includes/session/Session.php:48) in /home/lestanvi/wiki/includes/changes/ChannelFeed.php on line 100

Warning: Cannot modify header information - headers already sent by (output started at /home/lestanvi/wiki/includes/session/Session.php:48) in /home/lestanvi/wiki/includes/WebResponse.php on line 74

Warning: Cannot modify header information - headers already sent by (output started at /home/lestanvi/wiki/includes/session/Session.php:48) in /home/lestanvi/wiki/includes/WebResponse.php on line 74

Warning: Cannot modify header information - headers already sent by (output started at /home/lestanvi/wiki/includes/session/Session.php:48) in /home/lestanvi/wiki/includes/WebResponse.php on line 74
https://wiki.lestanville.eu/api.php?action=feedcontributions&feedformat=atom&user=Guillaume 2026-07-11T08:44:08Z Contributions de l’utilisateur MediaWiki 1.36.3 https://wiki.lestanville.eu/index.php?title=Logiciels&diff=40 2022-11-04T13:55:03Z

<p>Guillaume : /* Test logiciels et intégration continue */</p> <hr /> <div>Il s&#039;agit ici d&#039;un résumé de logiciels que j&#039;ai découvert et/ou que j&#039;utilise<br /> <br /> == Test logiciels et intégration continue ==<br /> * Jenkins<br /> * Github actions<br /> * Gitlab CI<br /> * Selenium<br /> * Postman<br /> * Katalon<br /> <br /> === Postman ===<br /> Avant Postman on utilisait curl avec un shell. Ca marche mais ce n&#039;était pas très pratique. J&#039;ai essayé.<br /> L&#039;interface permet de concevoir des requêtes HTTP, de récupérer le contenu et de valider le retour.<br /> <br /> Il dispose d&#039;un système très pratique de variables qui peu varier en fonction de l&#039;environnement: test, prod, etc.<br /> <br /> Je m&#039;en sers essentiellement pour tester les API.<br /> <br /> === Selenium ===<br /> En fait il existe deux sorte de Selenium. Le plus connu est vraisemblablement Selenium IDE. Il s&#039;agit d&#039;un plugin à installer dans<br /> son navigateur et il permet de créer des scénarios de test. <br /> <br /> L&#039;autre est un serveur autonome qui permet de mettre en place des tests fonctionnels complets avec les librairies de test unitaire.<br /> Pour fonctionner correctement il a besoin d&#039;un pilote (driver) en fonction du navigateur ciblé.<br /> <br /> === Katalon ===<br /> Il se décline en deux versions: Katalon Studio et Katalon Recorder.<br /> <br /> Ce dernier est similaire à Selenium IDE. Il s&#039;agit d&#039;une extension à installer dans le navigateur. Je le trouve plus complet.<br /> <br /> L&#039;autre version est un &quot;must have&quot;. C&#039;est un éditeur complet qui permet de mettre en place des tests complexes dans un environnement de bureau. <br /> Avec lui on peut tester des applications Web mais également des applications mobiles. Ouais rien que ça !!<br /> <br /> == Editeurs et IDE ==<br /> * Visual Studio Code<br /> * Visual Studio<br /> * Netbeans<br /> * Eclipse<br /> * PHPStorm<br /> <br /> == Langages de programmation ==<br /> * Powershell<br /> * Bash<br /> * Basic<br /> * Go<br /> * Rust<br /> * PHP<br /> <br /> <br /> == Gestion de référentiel et de changements ==<br /> * subversion<br /> * git<br /> * github<br /> * gitlab<br /> * gitea<br /> <br /> == Bases de données ==<br /> * Mysql<br /> * Mariadb<br /> * Postgresql<br /> * SQL Server<br /> * Oracle<br /> * Sqlite<br /> <br /> == Serveurs d&#039;application ==<br /> * Apache<br /> * Nginx<br /> * Nodejs<br /> * Deno<br /> * Payara et Payara micro<br /> <br /> Et bien d&#039;autres…<br /> <br /> === Apache ===<br /> Maintenu par la fondation Apache, c&#039;est le plus populaire. Sa configuration ressemble a du XML avec un système de balise.<br /> Il est très complet et permet la plupart des fantaisies.<br /> <br /> === NGinx ===<br /> Il a été créé à l&#039;origine pour faire un serveur d&#039;application plus rapide et plus simple à configurer qu&#039;Apache.<br /> Sa configuration se base sur un format JSON.<br /> <br /> === Tomcat ===<br /> Il s&#039;agit d&#039;un serveur d&#039;application destiné principalement aux application réalisées en Java.<br /> Il est maintenu par la fondation Apache.<br /> Sa configuration est en XML.<br /> <br /> === Payara ===<br /> Il s&#039;agit d&#039;un fork de Glassfish qui est également un serveur pour applications Java.<br /> Il dispose d&#039;une interface pour gérer les applications.<br /> <br /> === Payara Micro ===<br /> C&#039;est mon préféré. Bon, ok, il n&#039;a pas d&#039;interface de gestion et tout se passe avec la ligne de commande. Mais pour du développement, il fait le job et même très bien.<br /> Son grand intérêt est qu&#039;on n&#039;a pas besoin d&#039;un serveur gourmand en ressource pour faire tourner une application annexe. Il est excessivement léger et facile à installer: juste un jar à lancer.<br /> La dernière version (5.201) que je dispose fait 80 Mo.<br /> <br /> Par exemple je fait tourner Jenkins en local avec lui.<br /> <br /> === Nodejs ===<br /> Certains préféreront dire &quot;node.js&quot;.<br /> L&#039;idée de départ est de créer un serveur pour applications complètement rédigées en Ecmascript (le nom officiel de javascript).<br /> Sauf que son gestionnaire de paquet &quot;npm&quot; est tellement puissant qu&#039;aujourd&#039;hui on l&#039;installe juste pour ajouter des dépendances en javascript.<br /> <br /> === Deno ===<br /> Vous la trouvez l&#039;astuce ? Et bien oui, il s&#039;agit d&#039;un concurrent affiché à Nodejs. Son mot d&#039;ordre: faire plus simple et plus rapide que Nodejs.<br /> Il semble que le pari soit tenu.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Logiciels&diff=39 2022-11-04T13:34:51Z

<p>Guillaume : /* Bases de données */</p> <hr /> <div>Il s&#039;agit ici d&#039;un résumé de logiciels que j&#039;ai découvert et/ou que j&#039;utilise<br /> <br /> == Test logiciels et intégration continue ==<br /> * Jenkins<br /> * Github actions<br /> * Gitlab CI<br /> * Selenium<br /> * Postman<br /> * Katalon<br /> <br /> == Editeurs et IDE ==<br /> * Visual Studio Code<br /> * Visual Studio<br /> * Netbeans<br /> * Eclipse<br /> * PHPStorm<br /> <br /> == Langages de programmation ==<br /> * Powershell<br /> * Bash<br /> * Basic<br /> * Go<br /> * Rust<br /> * PHP<br /> <br /> <br /> == Gestion de référentiel et de changements ==<br /> * subversion<br /> * git<br /> * github<br /> * gitlab<br /> * gitea<br /> <br /> == Bases de données ==<br /> * Mysql<br /> * Mariadb<br /> * Postgresql<br /> * SQL Server<br /> * Oracle<br /> * Sqlite<br /> <br /> == Serveurs d&#039;application ==<br /> * Apache<br /> * Nginx<br /> * Nodejs<br /> * Deno<br /> * Payara et Payara micro<br /> <br /> Et bien d&#039;autres…<br /> <br /> === Apache ===<br /> Maintenu par la fondation Apache, c&#039;est le plus populaire. Sa configuration ressemble a du XML avec un système de balise.<br /> Il est très complet et permet la plupart des fantaisies.<br /> <br /> === NGinx ===<br /> Il a été créé à l&#039;origine pour faire un serveur d&#039;application plus rapide et plus simple à configurer qu&#039;Apache.<br /> Sa configuration se base sur un format JSON.<br /> <br /> === Tomcat ===<br /> Il s&#039;agit d&#039;un serveur d&#039;application destiné principalement aux application réalisées en Java.<br /> Il est maintenu par la fondation Apache.<br /> Sa configuration est en XML.<br /> <br /> === Payara ===<br /> Il s&#039;agit d&#039;un fork de Glassfish qui est également un serveur pour applications Java.<br /> Il dispose d&#039;une interface pour gérer les applications.<br /> <br /> === Payara Micro ===<br /> C&#039;est mon préféré. Bon, ok, il n&#039;a pas d&#039;interface de gestion et tout se passe avec la ligne de commande. Mais pour du développement, il fait le job et même très bien.<br /> Son grand intérêt est qu&#039;on n&#039;a pas besoin d&#039;un serveur gourmand en ressource pour faire tourner une application annexe. Il est excessivement léger et facile à installer: juste un jar à lancer.<br /> La dernière version (5.201) que je dispose fait 80 Mo.<br /> <br /> Par exemple je fait tourner Jenkins en local avec lui.<br /> <br /> === Nodejs ===<br /> Certains préféreront dire &quot;node.js&quot;.<br /> L&#039;idée de départ est de créer un serveur pour applications complètement rédigées en Ecmascript (le nom officiel de javascript).<br /> Sauf que son gestionnaire de paquet &quot;npm&quot; est tellement puissant qu&#039;aujourd&#039;hui on l&#039;installe juste pour ajouter des dépendances en javascript.<br /> <br /> === Deno ===<br /> Vous la trouvez l&#039;astuce ? Et bien oui, il s&#039;agit d&#039;un concurrent affiché à Nodejs. Son mot d&#039;ordre: faire plus simple et plus rapide que Nodejs.<br /> Il semble que le pari soit tenu.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Logiciels&diff=38 2022-11-04T13:33:39Z

<p>Guillaume : /* Serveurs d&#039;application */</p> <hr /> <div>Il s&#039;agit ici d&#039;un résumé de logiciels que j&#039;ai découvert et/ou que j&#039;utilise<br /> <br /> == Test logiciels et intégration continue ==<br /> * Jenkins<br /> * Github actions<br /> * Gitlab CI<br /> * Selenium<br /> * Postman<br /> * Katalon<br /> <br /> == Editeurs et IDE ==<br /> * Visual Studio Code<br /> * Visual Studio<br /> * Netbeans<br /> * Eclipse<br /> * PHPStorm<br /> <br /> == Langages de programmation ==<br /> * Powershell<br /> * Bash<br /> * Basic<br /> * Go<br /> * Rust<br /> * PHP<br /> <br /> <br /> == Gestion de référentiel et de changements ==<br /> * subversion<br /> * git<br /> * github<br /> * gitlab<br /> * gitea<br /> <br /> == Bases de données ==<br /> * Mysql<br /> * Mariadb<br /> * Postgresql<br /> * Oracle<br /> <br /> == Serveurs d&#039;application ==<br /> * Apache<br /> * Nginx<br /> * Nodejs<br /> * Deno<br /> * Payara et Payara micro<br /> <br /> Et bien d&#039;autres…<br /> <br /> === Apache ===<br /> Maintenu par la fondation Apache, c&#039;est le plus populaire. Sa configuration ressemble a du XML avec un système de balise.<br /> Il est très complet et permet la plupart des fantaisies.<br /> <br /> === NGinx ===<br /> Il a été créé à l&#039;origine pour faire un serveur d&#039;application plus rapide et plus simple à configurer qu&#039;Apache.<br /> Sa configuration se base sur un format JSON.<br /> <br /> === Tomcat ===<br /> Il s&#039;agit d&#039;un serveur d&#039;application destiné principalement aux application réalisées en Java.<br /> Il est maintenu par la fondation Apache.<br /> Sa configuration est en XML.<br /> <br /> === Payara ===<br /> Il s&#039;agit d&#039;un fork de Glassfish qui est également un serveur pour applications Java.<br /> Il dispose d&#039;une interface pour gérer les applications.<br /> <br /> === Payara Micro ===<br /> C&#039;est mon préféré. Bon, ok, il n&#039;a pas d&#039;interface de gestion et tout se passe avec la ligne de commande. Mais pour du développement, il fait le job et même très bien.<br /> Son grand intérêt est qu&#039;on n&#039;a pas besoin d&#039;un serveur gourmand en ressource pour faire tourner une application annexe. Il est excessivement léger et facile à installer: juste un jar à lancer.<br /> La dernière version (5.201) que je dispose fait 80 Mo.<br /> <br /> Par exemple je fait tourner Jenkins en local avec lui.<br /> <br /> === Nodejs ===<br /> Certains préféreront dire &quot;node.js&quot;.<br /> L&#039;idée de départ est de créer un serveur pour applications complètement rédigées en Ecmascript (le nom officiel de javascript).<br /> Sauf que son gestionnaire de paquet &quot;npm&quot; est tellement puissant qu&#039;aujourd&#039;hui on l&#039;installe juste pour ajouter des dépendances en javascript.<br /> <br /> === Deno ===<br /> Vous la trouvez l&#039;astuce ? Et bien oui, il s&#039;agit d&#039;un concurrent affiché à Nodejs. Son mot d&#039;ordre: faire plus simple et plus rapide que Nodejs.<br /> Il semble que le pari soit tenu.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Logiciels&diff=37 2022-11-04T13:05:00Z

<p>Guillaume : </p> <hr /> <div>Il s&#039;agit ici d&#039;un résumé de logiciels que j&#039;ai découvert et/ou que j&#039;utilise<br /> <br /> == Test logiciels et intégration continue ==<br /> * Jenkins<br /> * Github actions<br /> * Gitlab CI<br /> * Selenium<br /> * Postman<br /> * Katalon<br /> <br /> == Editeurs et IDE ==<br /> * Visual Studio Code<br /> * Visual Studio<br /> * Netbeans<br /> * Eclipse<br /> * PHPStorm<br /> <br /> == Langages de programmation ==<br /> * Powershell<br /> * Bash<br /> * Basic<br /> * Go<br /> * Rust<br /> * PHP<br /> <br /> <br /> == Gestion de référentiel et de changements ==<br /> * subversion<br /> * git<br /> * github<br /> * gitlab<br /> * gitea<br /> <br /> == Bases de données ==<br /> * Mysql<br /> * Mariadb<br /> * Postgresql<br /> * Oracle<br /> <br /> == Serveurs d&#039;application ==<br /> * Apache<br /> * Nginx<br /> * Nodejs<br /> * Deno<br /> * Payara et Payara micro</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Logiciels&diff=36 2022-11-04T11:27:53Z

<p>Guillaume : </p> <hr /> <div>Il s&#039;agit ici d&#039;un résumé de logiciels que j&#039;ai découvert et/ou que j&#039;utilise<br /> <br /> # Test logiciels et intégration continue<br /> * Jenkins<br /> * Github actions<br /> * Gitlab CI<br /> * Selenium<br /> * Postman<br /> * Katalon<br /> <br /> # Editeurs et IDE<br /> * Visual Studio Code<br /> * Visual Studio<br /> * Netbeans<br /> * Eclipse<br /> * PHPStorm<br /> <br /> # Langages de programmation<br /> * Powershell<br /> * Bash<br /> * Basic<br /> * Go<br /> * Rust<br /> * PHP<br /> <br /> <br /> # Gestion de référentiel et de changements<br /> - subversion<br /> - git<br /> - github<br /> - gitlab<br /> - gitea<br /> <br /> <br /> # Bases de données<br /> - Mysql<br /> - Mariadb<br /> - Postgresql<br /> - Oracle<br /> <br /> # Serveurs d&#039;application<br /> - Apache<br /> - Nginx<br /> - Nodejs<br /> - Deno<br /> - Payara et Payara micro</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Logiciels&diff=35 2022-11-04T11:26:45Z

<p>Guillaume : Création de la page</p> <hr /> <div>Il s&#039;agit ici d&#039;un résumé de logiciels que j&#039;ai découvert et/ou que j&#039;utilise<br /> <br /> # Test logiciels et intégration continue<br /> - Jenkins<br /> - Github actions<br /> - Gitlab CI<br /> - Selenium<br /> - Postman<br /> - Katalon<br /> <br /> # Editeurs et IDE<br /> - Visual Studio Code<br /> - Visual Studio<br /> - Netbeans<br /> - Eclipse<br /> - PHPStorm<br /> <br /> # Langages de programmation<br /> - Powershell<br /> - Bash<br /> - Basic<br /> - Go<br /> - Rust<br /> - PHP<br /> <br /> <br /> # Gestion de référentiel et de changements<br /> - subversion<br /> - git<br /> - github<br /> - gitlab<br /> - gitea<br /> <br /> <br /> # Bases de données<br /> - Mysql<br /> - Mariadb<br /> - Postgresql<br /> - Oracle<br /> <br /> # Serveurs d&#039;application<br /> - Apache<br /> - Nginx<br /> - Nodejs<br /> - Deno<br /> - Payara et Payara micro</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=34 2022-11-04T11:13:17Z

<p>Guillaume : ajout des découvertes</p> <hr /> <div>Bienvenue sur ce wiki destiné au monde de la programmation et des notions qui gravitent autour.<br /> <br /> Au menu:<br /> * [[algorithmique|Les algorithmes]]<br /> * [[Paradigmes|Les paradigmes et concepts]]<br /> * [[Languages|Les langages de programmation]]<br /> * [[Notions|Notions de base sur la programmation et l&#039;informatique]]<br /> * [[Systèmes d&#039;exploitation|Les systèmes d&#039;exploitation]]<br /> * [[Outils|Les outils du développeur]]<br /> * [[Concepts avancés]]<br /> * [[Logiciels|Mes découvertes en logiciels]]<br /> &lt;!-- <br /> [[Ancien accueil]]<br /> --&gt;</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Num%C3%A9ration&diff=33 2022-09-02T12:58:22Z

<p>Guillaume : /* Le binaire */</p> <hr /> <div>Les système de numération<br /> <br /> == Le binaire ==<br /> Le processeur en lui-même ne gère que des bits. On dit qu&#039;il utilise le système binaire. <br /> On résume souvent au zéro (0) et au un (1) pour distinguer les deux états. Ceci est bien pratique pour réaliser des calculs.<br /> Toutefois on parlerait plutôt d&#039;état actif et d&#039;état repos. On associe le 1 à l&#039;état actif et le 0 à l&#039;état repos.<br /> <br /> Par exemple :<br /> * La porte serait ouverte ou fermée<br /> * La lumière serait allumée ou éteinte<br /> * Le niveau de l&#039;eau serait haut ou bas<br /> * etc.<br /> <br /> Une algèbre existe pour manipuler et combiner ces valeurs. Il s&#039;agit de l&#039;algèbre de Boole.<br /> <br /> A là base il existe trois opérateurs: le ET, le OU et le NON. <br /> D&#039;autres opérateurs existent mais en réalité ils peuvent être construit à partir des 3 précédents: XOU ou OU exclusif, NAND ou NOT AND, IMP ou implication.<br /> <br /> [[Fichier:Portes logiques.png|cadre|Principales portes logiques]]<br /> <br /> === Le ET logique ===<br /> La sortie du ET est vraie si et seulement si les 2 entrées sont vraies.<br /> <br /> Il est souvent noté par le point.<br /> <br /> === Le OU logique ===<br /> La sortie du OU est vraie si et seulement si l&#039;une des 2 entrées au moins est vraie.<br /> <br /> Il est souvent noté par le signe plus (+).<br /> <br /> === Le NON logique ===<br /> La sortie du NON est toujours l&#039;opposé de l&#039;entrée.<br /> <br /> Il est représenté par une barre horizontale au-dessus de l&#039;expression.<br /> <br /> == Les entiers ==<br /> Une succession de 0 et de 1 c&#039;est bien joli, mais ce n&#039;est pas trop parlant pour un humain qui à l&#039;habitude de manipuler les nombres en base décimale.<br /> <br /> Pour stocker des nombre entiers nous utilisons des regroupements de bits:<br /> * le tercet: permet de représenter des chiffres de 0 à 7 en base octale (base 8).<br /> * le quartet: permet de représenté un chiffre hexadécimal de 0 à F (0 à 15 en décimal).<br /> * le septet: représente des nombres de 0 à 127.<br /> * l&#039;octet: représente des nombres de 0 à 255. C&#039;est souvent une unité de base utilisée avec des multiples. Il est exactement écrit avec deux chiffres hexadécimaux.<br /> <br /> Les entiers de taille plus grandes sont représenté dans des suites d&#039;octets:<br /> * l&#039;entier court (short, shortint, int16): 2 octets. De 0 à 65535.<br /> * l&#039;entier: (int, integer, int32): 4 octets. De 0 à 2^32-1.<br /> * l&#039;entier long (long, int64): 8 octets. De 0 à 2^64-1.<br /> * l&#039;entier long long, ou entier géant (bigint, int128): 16 octets. De 0 à 2^128-1.<br /> <br /> Selon les processeurs les bits sont disposés en mémoire en partant du bit le plus significatif ou bien du moins significatif. Nous parlerons ainsi de MSB pour &quot;most significant bit&quot; et LSB pour &quot;less significant bit&quot;.<br /> <br /> Le mot: il est possible que vous rencontrerez ce terme dans de la documentation informatique. Il s&#039;agit ici du mot machine. Il s&#039;agit du nombre le plus grand qu&#039;un processeur soit capable de manipuler à chaque instruction élémentaire. Ainsi un processeur de 32 bits est capable de manipuler des nombres entiers de 32 bits.<br /> <br /> == Les entiers négatifs ==<br /> Jusqu&#039;ici nous n&#039;avons parlé que des entiers positifs. Or les unités arithmétiques des processeurs sont capables de manipuler des entiers négatifs. Comment fait-on pour les représenter ?<br /> Et bien nous utilisons le bit le plus significatif pour indiquer qu&#039;un nombre est négatif (1) ou positif (0).<br /> <br /> Mais comment fait-on pour différencier les entiers avec ou sans signes ? Dans l&#039;absolu on ne sait pas faire la différence. Seul les programmes savent comment convertir ces nombres pour l&#039;afficher correctement.<br /> <br /> == L&#039;hexadécimal ==<br /> On peut parler aussi de la base 16. Les chiffres sont : 0 à 9, puis a, b, c, d, e et f. Les lettres peuvent être en minuscule ou en majuscule. Cela n&#039;a pas d&#039;importance.<br /> Cette base est très souvent employée. Elle a l&#039;avantage d&#039;être compacte, explicite et fixe. Un octet sera toujours représenté par 2 chiffres hexa.<br /> <br /> Pour convertir de l&#039;hexa vers le décimal: pour chaque chiffre on multiplie le nombre en décimal par une puissance de 16 en fonction de sa position.<br /> Exemples (le plus significatif est à gauche):<br /> * 8a: 10 + 16 * 8 = 138<br /> * af: 15 + 16 * 10 = 175<br /> * 3fea: 10 + 14 * 16 + 15 * 16 * 16 + 3 * 16 * 16 * 16 = 16362<br /> <br /> == Les nombres décimaux ==<br /> Ici nous allons retrouver différentes façons de stocker les nombre décimaux.<br /> <br /> === A virgule fixe ===<br /> Le principe est simple. En prend un nombre entier et on déplace la virgule d&#039;autant de chiffre que souhaité.<br /> Pour savoir comment est placé le séparateur décimal, seul le programme sait. Il s&#039;agit d&#039;une convention pour savoir combien de chiffres on place après la virgule.<br /> <br /> L&#039;avantage de cette façon de faire est que les additions et les soustractions sont exactes. Le principal inconvénient est qu&#039;on ne peut pas stocker des nombres très très grands. L&#039;espace de stockage est directement proportionnel au nombre de chiffres à stocker.<br /> <br /> On utilise ce format essentiellement pour la finance et la comptabilité ou la précision est importante.<br /> <br /> === A virgule flottante ===<br /> Bon là, ça se complique. L&#039;objectif de ce format est de pouvoir stocker des nombres de grande taille en prenant le moins de place possible. On utilise pour cela le format IEEE. Vous pouvez consulter la page [https://fr.wikipedia.org/wiki/IEEE_754 Wikipédia] pour plus d&#039;informations.<br /> <br /> Pour la base, dans une série d&#039;octets on stocke les informations pour reconstituer le nombre. Les différents parties sont: le signe (1 bit), la mantisse et l&#039;exposant.<br /> Vous commencer à percevoir le problème que cela pose ? Il s&#039;agit d&#039;une approximation du nombre de départ. D&#039;une part à cause de la mantisse qui perd les chiffres les moins significatifs et d&#039;autres part à cause de l&#039;exposant qui fonctionne en base 2. Ainsi des nombre comme 1, 3, ou 10 ne sont pas stockés comme tels.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Num%C3%A9ration&diff=32 2022-09-02T12:53:34Z

<p>Guillaume : Ajout d&#039;un image</p> <hr /> <div>Les système de numération<br /> <br /> == Le binaire ==<br /> Le processeur en lui-même ne gère que des bits. On dit qu&#039;il utilise le système binaire. <br /> On résume souvent au zéro (0) et au un (1) pour distinguer les deux états. Ceci est bien pratique pour réaliser des calculs.<br /> Toutefois on parlerait plutôt d&#039;état actif et d&#039;état repos. On associe le 1 à l&#039;état actif et le 0 à l&#039;état repos.<br /> <br /> Par exemple :<br /> * La porte serait ouverte ou fermée<br /> * La lumière serait allumée ou éteinte<br /> * Le niveau de l&#039;eau serait haut ou bas<br /> * etc.<br /> <br /> Une algèbre existe pour manipuler et combiner ces valeurs. Il s&#039;agit de l&#039;algèbre de Boole.<br /> <br /> A là base il existe trois opérateurs: le ET, le OU et le NON. <br /> D&#039;autres opérateurs existent mais en réalité ils peuvent être construit à partir des 3 précédents: XOU ou OU exclusif, NAND ou NOT AND, IMP ou implication.<br /> <br /> [[Fichier:Portes logiques.png|vignette|Principales portes logiques]]<br /> <br /> === Le ET logique ===<br /> La sortie du ET est vraie si et seulement si les 2 entrées sont vraies.<br /> <br /> Il est souvent noté par le point.<br /> <br /> === Le OU logique ===<br /> La sortie du OU est vraie si et seulement si l&#039;une des 2 entrées au moins est vraie.<br /> <br /> Il est souvent noté par le signe plus (+).<br /> <br /> === Le NON logique ===<br /> La sortie du NON est toujours l&#039;opposé de l&#039;entrée.<br /> <br /> Il est représenté par une barre horizontale au-dessus de l&#039;expression.<br /> <br /> == Les entiers ==<br /> Une succession de 0 et de 1 c&#039;est bien joli, mais ce n&#039;est pas trop parlant pour un humain qui à l&#039;habitude de manipuler les nombres en base décimale.<br /> <br /> Pour stocker des nombre entiers nous utilisons des regroupements de bits:<br /> * le tercet: permet de représenter des chiffres de 0 à 7 en base octale (base 8).<br /> * le quartet: permet de représenté un chiffre hexadécimal de 0 à F (0 à 15 en décimal).<br /> * le septet: représente des nombres de 0 à 127.<br /> * l&#039;octet: représente des nombres de 0 à 255. C&#039;est souvent une unité de base utilisée avec des multiples. Il est exactement écrit avec deux chiffres hexadécimaux.<br /> <br /> Les entiers de taille plus grandes sont représenté dans des suites d&#039;octets:<br /> * l&#039;entier court (short, shortint, int16): 2 octets. De 0 à 65535.<br /> * l&#039;entier: (int, integer, int32): 4 octets. De 0 à 2^32-1.<br /> * l&#039;entier long (long, int64): 8 octets. De 0 à 2^64-1.<br /> * l&#039;entier long long, ou entier géant (bigint, int128): 16 octets. De 0 à 2^128-1.<br /> <br /> Selon les processeurs les bits sont disposés en mémoire en partant du bit le plus significatif ou bien du moins significatif. Nous parlerons ainsi de MSB pour &quot;most significant bit&quot; et LSB pour &quot;less significant bit&quot;.<br /> <br /> Le mot: il est possible que vous rencontrerez ce terme dans de la documentation informatique. Il s&#039;agit ici du mot machine. Il s&#039;agit du nombre le plus grand qu&#039;un processeur soit capable de manipuler à chaque instruction élémentaire. Ainsi un processeur de 32 bits est capable de manipuler des nombres entiers de 32 bits.<br /> <br /> == Les entiers négatifs ==<br /> Jusqu&#039;ici nous n&#039;avons parlé que des entiers positifs. Or les unités arithmétiques des processeurs sont capables de manipuler des entiers négatifs. Comment fait-on pour les représenter ?<br /> Et bien nous utilisons le bit le plus significatif pour indiquer qu&#039;un nombre est négatif (1) ou positif (0).<br /> <br /> Mais comment fait-on pour différencier les entiers avec ou sans signes ? Dans l&#039;absolu on ne sait pas faire la différence. Seul les programmes savent comment convertir ces nombres pour l&#039;afficher correctement.<br /> <br /> == L&#039;hexadécimal ==<br /> On peut parler aussi de la base 16. Les chiffres sont : 0 à 9, puis a, b, c, d, e et f. Les lettres peuvent être en minuscule ou en majuscule. Cela n&#039;a pas d&#039;importance.<br /> Cette base est très souvent employée. Elle a l&#039;avantage d&#039;être compacte, explicite et fixe. Un octet sera toujours représenté par 2 chiffres hexa.<br /> <br /> Pour convertir de l&#039;hexa vers le décimal: pour chaque chiffre on multiplie le nombre en décimal par une puissance de 16 en fonction de sa position.<br /> Exemples (le plus significatif est à gauche):<br /> * 8a: 10 + 16 * 8 = 138<br /> * af: 15 + 16 * 10 = 175<br /> * 3fea: 10 + 14 * 16 + 15 * 16 * 16 + 3 * 16 * 16 * 16 = 16362<br /> <br /> == Les nombres décimaux ==<br /> Ici nous allons retrouver différentes façons de stocker les nombre décimaux.<br /> <br /> === A virgule fixe ===<br /> Le principe est simple. En prend un nombre entier et on déplace la virgule d&#039;autant de chiffre que souhaité.<br /> Pour savoir comment est placé le séparateur décimal, seul le programme sait. Il s&#039;agit d&#039;une convention pour savoir combien de chiffres on place après la virgule.<br /> <br /> L&#039;avantage de cette façon de faire est que les additions et les soustractions sont exactes. Le principal inconvénient est qu&#039;on ne peut pas stocker des nombres très très grands. L&#039;espace de stockage est directement proportionnel au nombre de chiffres à stocker.<br /> <br /> On utilise ce format essentiellement pour la finance et la comptabilité ou la précision est importante.<br /> <br /> === A virgule flottante ===<br /> Bon là, ça se complique. L&#039;objectif de ce format est de pouvoir stocker des nombres de grande taille en prenant le moins de place possible. On utilise pour cela le format IEEE. Vous pouvez consulter la page [https://fr.wikipedia.org/wiki/IEEE_754 Wikipédia] pour plus d&#039;informations.<br /> <br /> Pour la base, dans une série d&#039;octets on stocke les informations pour reconstituer le nombre. Les différents parties sont: le signe (1 bit), la mantisse et l&#039;exposant.<br /> Vous commencer à percevoir le problème que cela pose ? Il s&#039;agit d&#039;une approximation du nombre de départ. D&#039;une part à cause de la mantisse qui perd les chiffres les moins significatifs et d&#039;autres part à cause de l&#039;exposant qui fonctionne en base 2. Ainsi des nombre comme 1, 3, ou 10 ne sont pas stockés comme tels.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Fichier:Portes_logiques.png&diff=31 2022-09-02T12:53:02Z

<p>Guillaume : </p> <hr /> <div>Tables de vérité de certaines portes logiques</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Languages&diff=30 2022-09-02T12:10:35Z

<p>Guillaume : Page créée avec « Je ne vais pas rentrer dans les détails, mais je vais évoquer quelques langages de programmations que j&#039;estime représentatif ou bien qui ont eu un impact sur l&#039;évoluti… »</p> <hr /> <div>Je ne vais pas rentrer dans les détails, mais je vais évoquer quelques langages de programmations que j&#039;estime représentatif ou bien qui ont eu un impact sur l&#039;évolution des langages.<br /> <br /> == De la machine à l&#039;humain : l&#039;assembleur ==<br /> Il ne faut pas se leurrer, la machine ne voit qu&#039;une succession de bits à interpréter. Sauf que pour l&#039;humain, ce n&#039;est pas lisible, ni même très parlant.<br /> <br /> Pour rendre le code machine lisible, on a inventer le langage d&#039;assemblage. A la base il s&#039;agit d&#039;un ensemble de mots mnémotechniques qui indiquent les instructions à exécuter.<br /> Le code source est passé dans un processeur d&#039;assemblage qui interpréter les mots pour les transformer en code binaire.<br /> <br /> C&#039;est assez spartiate, mais c&#039;est un début. <br /> <br /> D&#039;ailleurs certains compilateur de langages plus évolués comme le C généraient des scripts en langages d&#039;assemblage.<br /> <br /> Exemple de script pour le processeur 6502:<br /> <br /> :start<br /> LDA #0208<br /> CMP #40<br /> BNE suite<br /> JMP start<br /> :suite<br /> RTS<br /> <br /> <br /> == Le père de beaucoup : le C ==<br /> Et pourquoi le C ? En fait la syntaxe définie dans ce langage est reprise dans beaucoup de langages contemporains. Je pense à l&#039;Ecmascript, au Java, au C#, au PHP entre autres. <br /> <br /> Je pense entre autres au structures de contrôle et la création de fonction. Certes, il y a eu quelques variantes depuis, mais les bases sont là.<br /> <br /> double fact(double n) {<br /> if (n &lt;= 1) return 1;<br /> return n * fact(n -1);<br /> }<br /> <br /> == La programmation logique: Lisp et Prolog ==<br /> Le Lisp pose les bases de la programmation logique en utilisant un paradigme déclaratif.<br /> <br /> Le Prolog pousse un peu plus loin le concept de programmation logique avec des concepts d&#039;assertions.<br /> <br /> == L&#039;arrivée de l&#039;objet ==<br /> C&#039;est le langage Simula qui pose les bases de la programmation orientée objet. <br /> <br /> Viendront ensuite Smalltalk, le C++ et Objective-C.<br /> <br /> Le langage Java a permis de créer beaucoup d&#039;outils autour de la conception objet, et entre autres autour de la méthode UML.<br /> <br /> == Programmation fonctionnelle ==<br /> Je pense au langage Caml et sa version orientée objet Objective-Caml. Il y a également Erlang et Scheme.<br /> <br /> Le but de ces langages et d&#039;éviter les effets de bord dus aux affectation. Avec les langages impératifs on peut y arriver mais au prix d&#039;une grosse discipline.<br /> <br /> == Les mathématiques et les sciences ==<br /> Il y a eu des tentatives avec Mathematica, puis l&#039;environnement Matlab a pas mal démocratisé. Depuis c&#039;est le langage Python qui grâce à des librairies dédiées est devenu très populaire dans ces domaines.<br /> <br /> == Le Web dynamique ==<br /> Les première pages du Web était plutôt statiques avec le HTML. Le PHP a permis de dynamiser très facilement tout cela.<br /> <br /> D&#039;autres langages comme le Ruby, grâce à son framework Ruby On Rails, a lancé les frameworks de développement web avec l&#039;architecture Modèle-Vue-Contrôleur.<br /> <br /> Ca s&#039;est pour le côté serveur. Sauf que du côté du navigateur, il fallait ajouter des petites animations pour rendre la page plus attrayante. C&#039;est l&#039;Ecmascript plus connu sous le nom de Javascript qui prend le monopole. Aujourd&#039;hui à l&#039;aide d&#039;un service NodeJs on peut également écrire la partie serveur d&#039;une application avec ce langage.<br /> <br /> TypeScript et plus récemment Kotlin, sont capables de générer du JS lors de la compilation.<br /> <br /> == Les bases de données ==<br /> Le SQL s&#039;est imposé comme langage de référence pour interroger les bases de données. Oracle fait partie des pionniers. Mais ce langage s&#039;est beaucoup popularisé avec MySql et Postgresql.<br /> <br /> Chaque système de base de données dispose de son propre dialecte, mais la base reste commune.<br /> <br /> SELECT nom, prenom FROM utilisateur WHERE id=5;</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Architecture&diff=29 2022-09-02T09:51:12Z

<p>Guillaume : Page créée avec « == L&#039;unité centrale == Schéma de principe d&#039;une unité centrale Dans le schéma de principe y sont indiqués les principaux com… »</p> <hr /> <div>== L&#039;unité centrale ==<br /> [[Fichier:Unité centrale.png|vignette|Schéma de principe d&#039;une unité centrale]]<br /> <br /> Dans le schéma de principe y sont indiqués les principaux composants d&#039;un ordinateur.<br /> <br /> La partie la plus importante est l&#039;ULA pour Unité Logique et Arithmétique. C&#039;est cette partie qui exécute les différentes instructions lues en mémoire.<br /> <br /> Sa mémoire interne est essentiellement composée des [[Processeur|registres]]. <br /> <br /> Pour éviter que tout s&#039;emballe, une horloge permet de cadencer le tout. Certaines instructions ne prennent qu&#039;un tic à s&#039;exécuter alors que d&#039;autres peuvent en prendre plus.<br /> <br /> Les ports d&#039;entrée/sortie permettent à l&#039;unité centrale d&#039;échanger avec le monde extérieur et notamment avec les périphériques.<br /> <br /> J&#039;y ai cité les principaux comme le clavier, la carte graphique pour l&#039;affichage et une unité de stockage comme un disque dur.<br /> <br /> Mais on peut y ajouter d&#039;autres périphériques comme la souris, un lecteur de carte, etc.<br /> <br /> Je ne l&#039;ai pas indiqué, mais aujourd&#039;hui la plupart des périphériques communiquent par l&#039;intermédiaire d&#039;un bus.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Fichier:Unit%C3%A9_centrale.png&diff=28 2022-09-02T09:34:57Z

<p>Guillaume : Schéma global d&#039;une unité centrale</p> <hr /> <div>== Description ==<br /> Schéma global d&#039;une unité centrale</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Processeur&diff=27 2022-09-01T15:22:08Z

<p>Guillaume : </p> <hr /> <div>Le processeur est la partie centrale d&#039;un ordinateur. C&#039;est lui qui exécute les instructions données par un programme.<br /> Les processeur sont tous différents, mais ils ont des caractéristiques communes.<br /> <br /> Mais comment ça marche ?<br /> <br /> == L&#039;instruction ==<br /> L&#039;instruction est indiquée par un mot machine d&#039;une valeur bien particulière qui va indiquer au processeur ce qu&#039;il doit exécuter. Soit l&#039;instruction est seule, soit l&#039;instruction est suivie d&#039;un argument de taille variable. La taille de l&#039;argument dépend de l&#039;instruction.<br /> <br /> == Les registres ==<br /> Tout d&#039;abord le processeur utilise des registres dans lequel il stocke les résultats des instructions et lui permettent d&#039;aller chercher les données nécessaire à l&#039;instruction à exécuter.<br /> <br /> === Le pointeur d&#039;instruction (PC) ===<br /> Le pointeur d&#039;instruction indique l&#039;adresse de la prochaine instruction à exécuter. Après l&#039;exécution de l&#039;instruction il avance d&#039;autant de mots que l&#039;instruction occupe. Les instructions les plus élémentaires ne nécessitent qu&#039;un mot alors que des instructions plus complexe en occupent plus.<br /> <br /> Il arrive que le pointeur d&#039;instruction soit accompagné d&#039;un pointeur de segment mémoire lorsque la taille du mot machine est insuffisante pour adresser l&#039;ensemble de la mémoire.<br /> <br /> === Le registre d&#039;état (SR) ===<br /> Le registre d&#039;état recense les différents drapeaux d&#039;état qui sont altérés en fonction des instructions. <br /> Parmi ces drapeaux nous avons:<br /> * La retenue (carry flag)<br /> * Le dépassement (overflow): activé lorsqu&#039;un calcul dépasse la capacité d&#039;un mot machine.<br /> * Le zéro (zero flag): Change d&#039;état en fonction des instructions de comparaison.<br /> * Le signe (S) : activé lorsque le résultat d&#039;une instruction est une valeur négative<br /> <br /> === L&#039;accumulateur (A) ===<br /> Il s&#039;agit du registre principal pour les opérations arithmétiques et logique.<br /> <br /> === Le pointeur de pile (SP) ===<br /> La pile peut servir à stocker des résultats intermédiaires de calculs, mais également à stocker les adresses de retour pour les instructions d&#039;appel.<br /> <br /> === Les index (X, Y) ===<br /> La valeur en mémoire est récupérée ou stockée à l&#039;emplacement mémoire indiqué en décalant de la valeur de l&#039;index. Nous verrons plus qu&#039;il existe différents adressages indexés.<br /> <br /> == Les adressages ==<br /> Le processeur à besoin de consulter des données et de stocker le résultat des instructions. Pour cela il dispose de différents stratégies d&#039;adressage.<br /> J&#039;ai ajouté des exemples de ce que donne les différents mode d&#039;adressage. Pour cela j&#039;utilise la convention suivante:<br /> * A : accumulateur<br /> * PC : pointeur d&#039;instruction<br /> * Addr : adresse indiquée en opérande de l&#039;instruction<br /> * X : index<br /> * n : opérande direct<br /> * Mem[...] : indique une valeur en mémoire à l&#039;emplacement indiqué.<br /> * s : taille de l&#039;instruction avec ses opérandes.<br /> <br /> === L&#039;adressage implicite ===<br /> Certaines instructions comme par exemple l&#039;empilement ou le dépilement n&#039;ont pas besoin de définir une adresse. Dans ce cas elle est implicite<br /> <br /> === Adressage immédiat ===<br /> La donnée est un argument de l&#039;instruction.<br /> <br /> A &lt;- n<br /> <br /> === Adressage direct ===<br /> L&#039;instruction va chercher directement la valeur à l&#039;emplacement mémoire indiqué dans l&#039;instruction.<br /> <br /> A &lt;- Mem[Addr]<br /> <br /> === Adressage absolu ===<br /> Lors d&#039;instruction de saut on indique l&#039;adresse de destination.<br /> <br /> PC &lt;- Addr<br /> <br /> === Adressage relatif ===<br /> On indique ici une adresse qui correspond au pointeur d&#039;instruction plus un nombre de mots défini en argument. Ce mode d&#039;adressage est essentiellement utilisé dans instructions de saut conditionnel.<br /> <br /> PC &lt;- PC + n + s<br /> <br /> A &lt;- Mem[PC + n]<br /> <br /> === Adressage indirect ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire indiqué l&#039;adresse où il faut lire la donnée.<br /> A &lt;- Mem[Mem[Addr]]<br /> <br /> === Adressage indexé ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire en ajoutant la valeur de l&#039;index. Les adressage indexés sont de différentes natures.<br /> <br /> L&#039;adressage direct indexé: il s&#039;agit de lire à l&#039;emplacement mémoire indiqué par l&#039;opérande augmenté de la valeur de l&#039;index.<br /> <br /> A &lt;- Mem[Addr + X]<br /> <br /> L&#039;adressage indirect pré-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr + X]]<br /> <br /> L&#039;adressage indirect post-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr] + X]<br /> <br /> == Les instructions ==<br /> Je ne vais pas les détailler ici, parce que d&#039;une part chaque processeur dispose d&#039;un jeu d&#039;instruction plus ou moins étendu et que de toutes façon la liste serait trop longue.<br /> Je vais quand même aborder les principales.<br /> <br /> === Les sauts ===<br /> Dans la section précédente j&#039;avais évoqué différents types de saut. Il s&#039;agit d&#039;instructions qui manipulent directement le pointeur d&#039;instruction. <br /> <br /> ==== Le saut inconditionnel ====<br /> On indique au processeur l&#039;adresse de la prochaine instruction à exécuter.<br /> <br /> JUMP Addr<br /> <br /> ==== Le saut avec condition de retour ====<br /> Avant de réaliser le saut à l&#039;adresse indiquée, l&#039;adresse de l&#039;instruction suivante est poussée en pile. <br /> Cette instruction est utilisé pour réaliser des appels de sous-programme.<br /> <br /> CALL Addr<br /> <br /> ==== Le retour d&#039;appel ====<br /> L&#039;adresse de l&#039;instruction suivante est dépilée. Elle met fin à l&#039;appel de sous-programme.<br /> <br /> RETURN<br /> <br /> Il existe des instructions de retour qui indiquent en plus le nombre de mots à dépiler.<br /> <br /> RETURN n<br /> <br /> ==== Le saut conditionnel ====<br /> L&#039;adresse indiquée qu&#039;elle soit absolue ou relative ne sera prise en compte qu&#039;en fonction du drapeau d&#039;état testé.<br /> <br /> Cela correspond à des instructions du type:<br /> IF CarryFlag THEN JUMP Addr<br /> IF NOT ZeroFlag THEN JUMP +n<br /> <br /> === Manipulation de la pile ===<br /> La plupart des processeurs fonctionnent avec une pile. En plus des instructions lié à l&#039;appel de sous-programme, on peut empiler et dépiler directement. Il existe habituellement une instruction pour chaque registre du processeur.<br /> <br /> PUSH A, PULL X<br /> <br /> On peut par exemple sauvegarder en pile le registre d&#039;état, réaliser une opération quelconque, puis restaurer le registre d&#039;état depuis la pile.<br /> <br /> === La lecture de données ===<br /> La plupart des instructions de lecture affectent la valeur indiquée à l&#039;accumulateur. Il arrive également que les index puissent être également affectés directement.<br /> <br /> LOAD A, 50<br /> LOAD X, 00AF80F9<br /> <br /> === L&#039;écriture de donnée ===<br /> Il s&#039;agit de l&#039;opération inverse de la précédente. Normalement seul le contenu de l&#039;accumulateur est utilisé<br /> <br /> STORE 00AF80F9+X<br /> <br /> === Les comparaisons ===<br /> Ce type d&#039;instruction consiste à comparer la valeur de l&#039;accumulateur avec une valeur quelconque. Normalement c&#039;est le drapeau Zéro qui est affecté si les valeurs sont identiques ou non.<br /> <br /> COMP A, 10<br /> <br /> === Les opérations logiques ===<br /> J&#039;avis déjà évoqué les opérateurs logiques au niveau du bit. Ici, les opérateurs s&#039;appliquent à l&#039;ensemble du mot machine.<br /> <br /> ==== Le NON ====<br /> La valeur de chaque bit est inversé. Chaque 1 devient un zéro et réciproquement.<br /> <br /> Exemple:<br /> NOT 01101001 -&gt; 10010110<br /> <br /> ==== Le OU et le ET ====<br /> On sert sert du OU pour s&#039;assurer qu&#039;un bit en particulier soit actif, et le ET pour désactiver un bit. On parle ici de masquage.<br /> <br /> Par exemple:<br /> 00010001 OU 10001000 -&gt; 10011001<br /> 11110111 ET 00101111 -&gt; 00100111<br /> <br /> ==== Les glissements et les rotations ====<br /> Les glissements correspondent simplement à un décalage vers la gauche ou vers la droite de tous le bits du mot. Le bit ajouté est toujours à zéro. Le plus enlevé est perdu. Il peut arriver qu&#039;il soit stocké dans la retenue.<br /> Ces instructions correspondent en réalité à une multiplication ou une division entière par 2 (deux). Comme cette instructions est beaucoup plus rapide que les instructions arithmétique, les algorithmes qui s&#039;appuie sur le divisions et multiplications par deux sont particulièrement efficaces.<br /> <br /> La rotation est un raffinement du glissement en prenant en compte le bit qui sort. Il est alors réintroduit dans le bit ajouté lors du glissement.<br /> <br /> === Les opérateurs arithmétiques ===<br /> Les instructions les plus simples sont les opérations d&#039;incrémentation et de décrémentation. Il s&#039;agit d&#039;ajouter ou retirer 1 à la valeur du registre. L&#039;accumulateur et les registres d&#039;index sont concernés.<br /> <br /> Ensuite nous avons les additions et les soustractions et puis c&#039;est tout.<br /> <br /> Certains processeurs complexes incluent également la multiplication et la division entière.<br /> <br /> === Les entrées / sorties ===<br /> En plus d&#039;accéder à la mémoire, le processeur peut émettre ou recevoir des bits par l&#039;intermédiaire des ports d&#039;entrées / sorties. Ceci permet de commander des périphériques comme la carte graphique, le clavier ou le disque dur.<br /> <br /> En bref, ceci permet au processeur d&#039;interagir avec le monde extérieur.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Processeur&diff=26 2022-09-01T15:21:38Z

<p>Guillaume : Ajout des entrées / sorties</p> <hr /> <div>Le processeur est la partie centrale d&#039;un ordinateur. C&#039;est lui qui exécute les instructions données par un programme.<br /> Les processeur sont tous différents, mais ils ont des caractéristiques communes.<br /> <br /> Mais comment ça marche ?<br /> <br /> == L&#039;instruction ==<br /> L&#039;instruction est indiquée par un mot machine d&#039;une valeur bien particulière qui va indiquer au processeur ce qu&#039;il doit exécuter. Soit l&#039;instruction est seule, soit l&#039;instruction est suivie d&#039;un argument de taille variable. La taille de l&#039;argument dépend de l&#039;instruction.<br /> <br /> == Les registres ==<br /> Tout d&#039;abord le processeur utilise des registres dans lequel il stocke les résultats des instructions et lui permettent d&#039;aller chercher les données nécessaire à l&#039;instruction à exécuter.<br /> <br /> === Le pointeur d&#039;instruction (PC) ===<br /> Le pointeur d&#039;instruction indique l&#039;adresse de la prochaine instruction à exécuter. Après l&#039;exécution de l&#039;instruction il avance d&#039;autant de mots que l&#039;instruction occupe. Les instructions les plus élémentaires ne nécessitent qu&#039;un mot alors que des instructions plus complexe en occupent plus.<br /> <br /> Il arrive que le pointeur d&#039;instruction soit accompagné d&#039;un pointeur de segment mémoire lorsque la taille du mot machine est insuffisante pour adresser l&#039;ensemble de la mémoire.<br /> <br /> === Le registre d&#039;état (SR) ===<br /> Le registre d&#039;état recense les différents drapeaux d&#039;état qui sont altérés en fonction des instructions. <br /> Parmi ces drapeaux nous avons:<br /> * La retenue (carry flag)<br /> * Le dépassement (overflow): activé lorsqu&#039;un calcul dépasse la capacité d&#039;un mot machine.<br /> * Le zéro (zero flag): Change d&#039;état en fonction des instructions de comparaison.<br /> * Le signe (S) : activé lorsque le résultat d&#039;une instruction est une valeur négative<br /> <br /> === L&#039;accumulateur (A) ===<br /> Il s&#039;agit du registre principal pour les opérations arithmétiques et logique.<br /> <br /> === Le pointeur de pile (SP) ===<br /> La pile peut servir à stocker des résultats intermédiaires de calculs, mais également à stocker les adresses de retour pour les instructions d&#039;appel.<br /> <br /> === Les index (X, Y) ===<br /> La valeur en mémoire est récupérée ou stockée à l&#039;emplacement mémoire indiqué en décalant de la valeur de l&#039;index. Nous verrons plus qu&#039;il existe différents adressages indexés.<br /> <br /> == Les adressages ==<br /> Le processeur à besoin de consulter des données et de stocker le résultat des instructions. Pour cela il dispose de différents stratégies d&#039;adressage.<br /> J&#039;ai ajouté des exemples de ce que donne les différents mode d&#039;adressage. Pour cela j&#039;utilise la convention suivante:<br /> * A : accumulateur<br /> * PC : pointeur d&#039;instruction<br /> * Addr : adresse indiquée en opérande de l&#039;instruction<br /> * X : index<br /> * n : opérande direct<br /> * Mem[...] : indique une valeur en mémoire à l&#039;emplacement indiqué.<br /> * s : taille de l&#039;instruction avec ses opérandes.<br /> <br /> === L&#039;adressage implicite ===<br /> Certaines instructions comme par exemple l&#039;empilement ou le dépilement n&#039;ont pas besoin de définir une adresse. Dans ce cas elle est implicite<br /> <br /> === Adressage immédiat ===<br /> La donnée est un argument de l&#039;instruction.<br /> <br /> A &lt;- n<br /> <br /> === Adressage direct ===<br /> L&#039;instruction va chercher directement la valeur à l&#039;emplacement mémoire indiqué dans l&#039;instruction.<br /> <br /> A &lt;- Mem[Addr]<br /> <br /> === Adressage absolu ===<br /> Lors d&#039;instruction de saut on indique l&#039;adresse de destination.<br /> <br /> PC &lt;- Addr<br /> <br /> === Adressage relatif ===<br /> On indique ici une adresse qui correspond au pointeur d&#039;instruction plus un nombre de mots défini en argument. Ce mode d&#039;adressage est essentiellement utilisé dans instructions de saut conditionnel.<br /> <br /> PC &lt;- PC + n + s<br /> <br /> A &lt;- Mem[PC + n]<br /> <br /> === Adressage indirect ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire indiqué l&#039;adresse où il faut lire la donnée.<br /> A &lt;- Mem[Mem[Addr]]<br /> <br /> === Adressage indexé ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire en ajoutant la valeur de l&#039;index. Les adressage indexés sont de différentes natures.<br /> <br /> L&#039;adressage direct indexé: il s&#039;agit de lire à l&#039;emplacement mémoire indiqué par l&#039;opérande augmenté de la valeur de l&#039;index.<br /> <br /> A &lt;- Mem[Addr + X]<br /> <br /> L&#039;adressage indirect pré-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr + X]]<br /> <br /> L&#039;adressage indirect post-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr] + X]<br /> <br /> == Les instructions ==<br /> Je ne vais pas les détailler ici, parce que d&#039;une part chaque processeur dispose d&#039;un jeu d&#039;instruction plus ou moins étendu et que de toutes façon la liste serait trop longue.<br /> Je vais quand même aborder les principales.<br /> <br /> === Les sauts ===<br /> Dans la section précédente j&#039;avais évoqué différents types de saut. Il s&#039;agit d&#039;instructions qui manipulent directement le pointeur d&#039;instruction. <br /> <br /> ==== Le saut inconditionnel ====<br /> On indique au processeur l&#039;adresse de la prochaine instruction à exécuter.<br /> <br /> JUMP Addr<br /> <br /> ==== Le saut avec condition de retour ====<br /> Avant de réaliser le saut à l&#039;adresse indiquée, l&#039;adresse de l&#039;instruction suivante est poussée en pile. <br /> Cette instruction est utilisé pour réaliser des appels de sous-programme.<br /> <br /> CALL Addr<br /> <br /> ==== Le retour d&#039;appel ====<br /> L&#039;adresse de l&#039;instruction suivante est dépilée. Elle met fin à l&#039;appel de sous-programme.<br /> <br /> RETURN<br /> <br /> Il existe des instructions de retour qui indiquent en plus le nombre de mots à dépiler.<br /> <br /> RETURN n<br /> <br /> ==== Le saut conditionnel ====<br /> L&#039;adresse indiquée qu&#039;elle soit absolue ou relative ne sera prise en compte qu&#039;en fonction du drapeau d&#039;état testé.<br /> <br /> Cela correspond à des instructions du type:<br /> IF CarryFlag THEN JUMP Addr<br /> IF NOT ZeroFlag THEN JUMP +n<br /> <br /> === Manipulation de la pile ===<br /> La plupart des processeurs fonctionnent avec une pile. En plus des instructions lié à l&#039;appel de sous-programme, on peut empiler et dépiler directement. Il existe habituellement une instruction pour chaque registre du processeur.<br /> <br /> PUSH A, PULL X<br /> <br /> On peut par exemple sauvegarder en pile le registre d&#039;état, réaliser une opération quelconque, puis restaurer le registre d&#039;état depuis la pile.<br /> <br /> === La lecture de données ===<br /> La plupart des instructions de lecture affectent la valeur indiquée à l&#039;accumulateur. Il arrive également que les index puissent être également affectés directement.<br /> <br /> LOAD A, 50<br /> LOAD X, 00AF80F9<br /> <br /> === L&#039;écriture de donnée ===<br /> Il s&#039;agit de l&#039;opération inverse de la précédente. Normalement seul le contenu de l&#039;accumulateur est utilisé<br /> <br /> STORE 00AF80F9+X<br /> <br /> === Les comparaisons ====<br /> Ce type d&#039;instruction consiste à comparer la valeur de l&#039;accumulateur avec une valeur quelconque. Normalement c&#039;est le drapeau Zéro qui est affecté si les valeurs sont identiques ou non.<br /> <br /> COMP A, 10<br /> <br /> === Les opérations logiques ===<br /> J&#039;avis déjà évoqué les opérateurs logiques au niveau du bit. Ici, les opérateurs s&#039;appliquent à l&#039;ensemble du mot machine.<br /> <br /> ==== Le NON ====<br /> La valeur de chaque bit est inversé. Chaque 1 devient un zéro et réciproquement.<br /> <br /> Exemple:<br /> NOT 01101001 -&gt; 10010110<br /> <br /> ==== Le OU et le ET ====<br /> On sert sert du OU pour s&#039;assurer qu&#039;un bit en particulier soit actif, et le ET pour désactiver un bit. On parle ici de masquage.<br /> <br /> Par exemple:<br /> 00010001 OU 10001000 -&gt; 10011001<br /> 11110111 ET 00101111 -&gt; 00100111<br /> <br /> ==== Les glissements et les rotations ====<br /> Les glissements correspondent simplement à un décalage vers la gauche ou vers la droite de tous le bits du mot. Le bit ajouté est toujours à zéro. Le plus enlevé est perdu. Il peut arriver qu&#039;il soit stocké dans la retenue.<br /> Ces instructions correspondent en réalité à une multiplication ou une division entière par 2 (deux). Comme cette instructions est beaucoup plus rapide que les instructions arithmétique, les algorithmes qui s&#039;appuie sur le divisions et multiplications par deux sont particulièrement efficaces.<br /> <br /> La rotation est un raffinement du glissement en prenant en compte le bit qui sort. Il est alors réintroduit dans le bit ajouté lors du glissement.<br /> <br /> === Les opérateurs arithmétiques ===<br /> Les instructions les plus simples sont les opérations d&#039;incrémentation et de décrémentation. Il s&#039;agit d&#039;ajouter ou retirer 1 à la valeur du registre. L&#039;accumulateur et les registres d&#039;index sont concernés.<br /> <br /> Ensuite nous avons les additions et les soustractions et puis c&#039;est tout.<br /> <br /> Certains processeurs complexes incluent également la multiplication et la division entière.<br /> <br /> === Les entrées / sorties ===<br /> En plus d&#039;accéder à la mémoire, le processeur peut émettre ou recevoir des bits par l&#039;intermédiaire des ports d&#039;entrées / sorties. Ceci permet de commander des périphériques comme la carte graphique, le clavier ou le disque dur.<br /> <br /> En bref, ceci permet au processeur d&#039;interagir avec le monde extérieur.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Processeur&diff=25 2022-09-01T15:10:26Z

<p>Guillaume : </p> <hr /> <div>Le processeur est la partie centrale d&#039;un ordinateur. C&#039;est lui qui exécute les instructions données par un programme.<br /> Les processeur sont tous différents, mais ils ont des caractéristiques communes.<br /> <br /> Mais comment ça marche ?<br /> <br /> == L&#039;instruction ==<br /> L&#039;instruction est indiquée par un mot machine d&#039;une valeur bien particulière qui va indiquer au processeur ce qu&#039;il doit exécuter. Soit l&#039;instruction est seule, soit l&#039;instruction est suivie d&#039;un argument de taille variable. La taille de l&#039;argument dépend de l&#039;instruction.<br /> <br /> == Les registres ==<br /> Tout d&#039;abord le processeur utilise des registres dans lequel il stocke les résultats des instructions et lui permettent d&#039;aller chercher les données nécessaire à l&#039;instruction à exécuter.<br /> <br /> === Le pointeur d&#039;instruction (PC) ===<br /> Le pointeur d&#039;instruction indique l&#039;adresse de la prochaine instruction à exécuter. Après l&#039;exécution de l&#039;instruction il avance d&#039;autant de mots que l&#039;instruction occupe. Les instructions les plus élémentaires ne nécessitent qu&#039;un mot alors que des instructions plus complexe en occupent plus.<br /> <br /> Il arrive que le pointeur d&#039;instruction soit accompagné d&#039;un pointeur de segment mémoire lorsque la taille du mot machine est insuffisante pour adresser l&#039;ensemble de la mémoire.<br /> <br /> === Le registre d&#039;état (SR) ===<br /> Le registre d&#039;état recense les différents drapeaux d&#039;état qui sont altérés en fonction des instructions. <br /> Parmi ces drapeaux nous avons:<br /> * La retenue (carry flag)<br /> * Le dépassement (overflow): activé lorsqu&#039;un calcul dépasse la capacité d&#039;un mot machine.<br /> * Le zéro (zero flag): Change d&#039;état en fonction des instructions de comparaison.<br /> * Le signe (S) : activé lorsque le résultat d&#039;une instruction est une valeur négative<br /> <br /> === L&#039;accumulateur (A) ===<br /> Il s&#039;agit du registre principal pour les opérations arithmétiques et logique.<br /> <br /> === Le pointeur de pile (SP) ===<br /> La pile peut servir à stocker des résultats intermédiaires de calculs, mais également à stocker les adresses de retour pour les instructions d&#039;appel.<br /> <br /> === Les index (X, Y) ===<br /> La valeur en mémoire est récupérée ou stockée à l&#039;emplacement mémoire indiqué en décalant de la valeur de l&#039;index. Nous verrons plus qu&#039;il existe différents adressages indexés.<br /> <br /> == Les adressages ==<br /> Le processeur à besoin de consulter des données et de stocker le résultat des instructions. Pour cela il dispose de différents stratégies d&#039;adressage.<br /> J&#039;ai ajouté des exemples de ce que donne les différents mode d&#039;adressage. Pour cela j&#039;utilise la convention suivante:<br /> * A : accumulateur<br /> * PC : pointeur d&#039;instruction<br /> * Addr : adresse indiquée en opérande de l&#039;instruction<br /> * X : index<br /> * n : opérande direct<br /> * Mem[...] : indique une valeur en mémoire à l&#039;emplacement indiqué.<br /> * s : taille de l&#039;instruction avec ses opérandes.<br /> <br /> === L&#039;adressage implicite ===<br /> Certaines instructions comme par exemple l&#039;empilement ou le dépilement n&#039;ont pas besoin de définir une adresse. Dans ce cas elle est implicite<br /> <br /> === Adressage immédiat ===<br /> La donnée est un argument de l&#039;instruction.<br /> <br /> A &lt;- n<br /> <br /> === Adressage direct ===<br /> L&#039;instruction va chercher directement la valeur à l&#039;emplacement mémoire indiqué dans l&#039;instruction.<br /> <br /> A &lt;- Mem[Addr]<br /> <br /> === Adressage absolu ===<br /> Lors d&#039;instruction de saut on indique l&#039;adresse de destination.<br /> <br /> PC &lt;- Addr<br /> <br /> === Adressage relatif ===<br /> On indique ici une adresse qui correspond au pointeur d&#039;instruction plus un nombre de mots défini en argument. Ce mode d&#039;adressage est essentiellement utilisé dans instructions de saut conditionnel.<br /> <br /> PC &lt;- PC + n + s<br /> <br /> A &lt;- Mem[PC + n]<br /> <br /> === Adressage indirect ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire indiqué l&#039;adresse où il faut lire la donnée.<br /> A &lt;- Mem[Mem[Addr]]<br /> <br /> === Adressage indexé ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire en ajoutant la valeur de l&#039;index. Les adressage indexés sont de différentes natures.<br /> <br /> L&#039;adressage direct indexé: il s&#039;agit de lire à l&#039;emplacement mémoire indiqué par l&#039;opérande augmenté de la valeur de l&#039;index.<br /> <br /> A &lt;- Mem[Addr + X]<br /> <br /> L&#039;adressage indirect pré-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr + X]]<br /> <br /> L&#039;adressage indirect post-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr] + X]<br /> <br /> == Les instructions ==<br /> Je ne vais pas les détailler ici, parce que d&#039;une part chaque processeur dispose d&#039;un jeu d&#039;instruction plus ou moins étendu et que de toutes façon la liste serait trop longue.<br /> Je vais quand même aborder les principales.<br /> <br /> === Les sauts ===<br /> Dans la section précédente j&#039;avais évoqué différents types de saut. Il s&#039;agit d&#039;instructions qui manipulent directement le pointeur d&#039;instruction. <br /> <br /> ==== Le saut inconditionnel ====<br /> On indique au processeur l&#039;adresse de la prochaine instruction à exécuter.<br /> <br /> JUMP Addr<br /> <br /> ==== Le saut avec condition de retour ====<br /> Avant de réaliser le saut à l&#039;adresse indiquée, l&#039;adresse de l&#039;instruction suivante est poussée en pile. <br /> Cette instruction est utilisé pour réaliser des appels de sous-programme.<br /> <br /> CALL Addr<br /> <br /> ==== Le retour d&#039;appel ====<br /> L&#039;adresse de l&#039;instruction suivante est dépilée. Elle met fin à l&#039;appel de sous-programme.<br /> <br /> RETURN<br /> <br /> Il existe des instructions de retour qui indiquent en plus le nombre de mots à dépiler.<br /> <br /> RETURN n<br /> <br /> ==== Le saut conditionnel ====<br /> L&#039;adresse indiquée qu&#039;elle soit absolue ou relative ne sera prise en compte qu&#039;en fonction du drapeau d&#039;état testé.<br /> <br /> Cela correspond à des instructions du type:<br /> IF CarryFlag THEN JUMP Addr<br /> IF NOT ZeroFlag THEN JUMP +n<br /> <br /> === Manipulation de la pile ===<br /> La plupart des processeurs fonctionnent avec une pile. En plus des instructions lié à l&#039;appel de sous-programme, on peut empiler et dépiler directement. Il existe habituellement une instruction pour chaque registre du processeur.<br /> <br /> PUSH A, PULL X<br /> <br /> On peut par exemple sauvegarder en pile le registre d&#039;état, réaliser une opération quelconque, puis restaurer le registre d&#039;état depuis la pile.<br /> <br /> === La lecture de données ===<br /> La plupart des instructions de lecture affectent la valeur indiquée à l&#039;accumulateur. Il arrive également que les index puissent être également affectés directement.<br /> <br /> LOAD A, 50<br /> LOAD X, 00AF80F9<br /> <br /> === L&#039;écriture de donnée ===<br /> Il s&#039;agit de l&#039;opération inverse de la précédente. Normalement seul le contenu de l&#039;accumulateur est utilisé<br /> <br /> STORE 00AF80F9+X<br /> <br /> === Les comparaisons ====<br /> Ce type d&#039;instruction consiste à comparer la valeur de l&#039;accumulateur avec une valeur quelconque. Normalement c&#039;est le drapeau Zéro qui est affecté si les valeurs sont identiques ou non.<br /> <br /> COMP A, 10<br /> <br /> === Les opérations logiques ===<br /> J&#039;avis déjà évoqué les opérateurs logiques au niveau du bit. Ici, les opérateurs s&#039;appliquent à l&#039;ensemble du mot machine.<br /> <br /> ==== Le NON ====<br /> La valeur de chaque bit est inversé. Chaque 1 devient un zéro et réciproquement.<br /> <br /> Exemple:<br /> NOT 01101001 -&gt; 10010110<br /> <br /> ==== Le OU et le ET ====<br /> On sert sert du OU pour s&#039;assurer qu&#039;un bit en particulier soit actif, et le ET pour désactiver un bit. On parle ici de masquage.<br /> <br /> Par exemple:<br /> 00010001 OU 10001000 -&gt; 10011001<br /> 11110111 ET 00101111 -&gt; 00100111<br /> <br /> ==== Les glissements et les rotations ====<br /> Les glissements correspondent simplement à un décalage vers la gauche ou vers la droite de tous le bits du mot. Le bit ajouté est toujours à zéro. Le plus enlevé est perdu. Il peut arriver qu&#039;il soit stocké dans la retenue.<br /> Ces instructions correspondent en réalité à une multiplication ou une division entière par 2 (deux). Comme cette instructions est beaucoup plus rapide que les instructions arithmétique, les algorithmes qui s&#039;appuie sur le divisions et multiplications par deux sont particulièrement efficaces.<br /> <br /> La rotation est un raffinement du glissement en prenant en compte le bit qui sort. Il est alors réintroduit dans le bit ajouté lors du glissement.<br /> <br /> === Les opérateurs arithmétiques ===<br /> Les instructions les plus simples sont les opérations d&#039;incrémentation et de décrémentation. Il s&#039;agit d&#039;ajouter ou retirer 1 à la valeur du registre. L&#039;accumulateur et les registres d&#039;index sont concernés.<br /> <br /> Ensuite nous avons les additions et les soustractions et puis c&#039;est tout.<br /> <br /> Certains processeurs complexes incluent également la multiplication et la division entière.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Processeur&diff=24 2022-09-01T15:09:48Z

<p>Guillaume : </p> <hr /> <div>Le processeur est la partie centrale d&#039;un ordinateur. C&#039;est lui qui exécute les instructions données par un programme.<br /> Les processeur sont tous différents, mais ils ont des caractéristiques communes.<br /> <br /> Mais comment ça marche ?<br /> <br /> == L&#039;instruction ==<br /> L&#039;instruction est indiquée par un mot machine d&#039;une valeur bien particulière qui va indiquer au processeur ce qu&#039;il doit exécuter. Soit l&#039;instruction est seule, soit l&#039;instruction est suivie d&#039;un argument de taille variable. La taille de l&#039;argument dépend de l&#039;instruction.<br /> <br /> == Les registres ==<br /> Tout d&#039;abord le processeur utilise des registres dans lequel il stocke les résultats des instructions et lui permettent d&#039;aller chercher les données nécessaire à l&#039;instruction à exécuter.<br /> <br /> === Le pointeur d&#039;instruction (PC) ===<br /> Le pointeur d&#039;instruction indique l&#039;adresse de la prochaine instruction à exécuter. Après l&#039;exécution de l&#039;instruction il avance d&#039;autant de mots que l&#039;instruction occupe. Les instructions les plus élémentaires ne nécessitent qu&#039;un mot alors que des instructions plus complexe en occupent plus.<br /> <br /> Il arrive que le pointeur d&#039;instruction soit accompagné d&#039;un pointeur de segment mémoire lorsque la taille du mot machine est insuffisante pour adresser l&#039;ensemble de la mémoire.<br /> <br /> === Le registre d&#039;état (SR) ===<br /> Le registre d&#039;état recense les différents drapeaux d&#039;état qui sont altérés en fonction des instructions. <br /> Parmi ces drapeaux nous avons:<br /> * La retenue (carry flag)<br /> * Le dépassement (overflow): activé lorsqu&#039;un calcul dépasse la capacité d&#039;un mot machine.<br /> * Le zéro (zero flag): Change d&#039;état en fonction des instructions de comparaison.<br /> * Le signe (S) : activé lorsque le résultat d&#039;une instruction est une valeur négative<br /> <br /> === L&#039;accumulateur (A) ===<br /> Il s&#039;agit du registre principal pour les opérations arithmétiques et logique.<br /> <br /> === Le pointeur de pile (SP) ===<br /> La pile peut servir à stocker des résultats intermédiaires de calculs, mais également à stocker les adresses de retour pour les instructions d&#039;appel.<br /> <br /> === Les index (X, Y) ===<br /> La valeur en mémoire est récupérée ou stockée à l&#039;emplacement mémoire indiqué en décalant de la valeur de l&#039;index. Nous verrons plus qu&#039;il existe différents adressages indexés.<br /> <br /> == Les adressages ==<br /> Le processeur à besoin de consulter des données et de stocker le résultat des instructions. Pour cela il dispose de différents stratégies d&#039;adressage.<br /> J&#039;ai ajouté des exemples de ce que donne les différents mode d&#039;adressage. Pour cela j&#039;utilise la convention suivante:<br /> * A : accumulateur<br /> * PC : pointeur d&#039;instruction<br /> * Addr : adresse indiquée en opérande de l&#039;instruction<br /> * X : index<br /> * n : opérande direct<br /> * Mem[...] : indique une valeur en mémoire à l&#039;emplacement indiqué.<br /> * s : taille de l&#039;instruction avec ses opérandes.<br /> <br /> === L&#039;adressage implicite ===<br /> Certaines instructions comme par exemple l&#039;empilement ou le dépilement n&#039;ont pas besoin de définir une adresse. Dans ce cas elle est implicite<br /> <br /> === Adressage immédiat ===<br /> La donnée est un argument de l&#039;instruction.<br /> <br /> A &lt;- n<br /> <br /> === Adressage direct ===<br /> L&#039;instruction va chercher directement la valeur à l&#039;emplacement mémoire indiqué dans l&#039;instruction.<br /> <br /> A &lt;- Mem[Addr]<br /> <br /> === Adressage absolu ===<br /> Lors d&#039;instruction de saut on indique l&#039;adresse de destination.<br /> <br /> PC &lt;- Addr<br /> <br /> === Adressage relatif ===<br /> On indique ici une adresse qui correspond au pointeur d&#039;instruction plus un nombre de mots défini en argument. Ce mode d&#039;adressage est essentiellement utilisé dans instructions de saut conditionnel.<br /> <br /> PC &lt;- PC + n + s<br /> <br /> A &lt;- Mem[PC + n]<br /> <br /> === Adressage indirect ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire indiqué l&#039;adresse où il faut lire la donnée.<br /> A &lt;- Mem[Mem[Addr]]<br /> <br /> === Adressage indexé ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire en ajoutant la valeur de l&#039;index. Les adressage indexés sont de différentes natures.<br /> <br /> L&#039;adressage direct indexé: il s&#039;agit de lire à l&#039;emplacement mémoire indiqué par l&#039;opérande augmenté de la valeur de l&#039;index.<br /> <br /> A &lt;- Mem[Addr + X]<br /> <br /> L&#039;adressage indirect pré-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr + X]]<br /> <br /> L&#039;adressage indirect post-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr] + X]<br /> <br /> == Les instructions ==<br /> Je ne vais pas les détailler ici, parce que d&#039;une part chaque processeur dispose d&#039;un jeu d&#039;instruction plus ou moins étendu et que de toutes façon la liste serait trop longue.<br /> Je vais quand même aborder les principales.<br /> <br /> === Les sauts ==<br /> Dans la section précédente j&#039;avais évoqué différents types de saut. Il s&#039;agit d&#039;instructions qui manipulent directement le pointeur d&#039;instruction. <br /> <br /> ==== Le saut inconditionnel ====<br /> On indique au processeur l&#039;adresse de la prochaine instruction à exécuter.<br /> <br /> JUMP Addr<br /> <br /> ==== Le saut avec condition de retour ====<br /> Avant de réaliser le saut à l&#039;adresse indiquée, l&#039;adresse de l&#039;instruction suivante est poussée en pile. <br /> Cette instruction est utilisé pour réaliser des appels de sous-programme.<br /> <br /> CALL Addr<br /> <br /> ==== Le retour d&#039;appel ====<br /> L&#039;adresse de l&#039;instruction suivante est dépilée. Elle met fin à l&#039;appel de sous-programme.<br /> <br /> RETURN<br /> <br /> Il existe des instructions de retour qui indiquent en plus le nombre de mots à dépiler.<br /> <br /> RETURN n<br /> <br /> ==== Le saut conditionnel ====<br /> L&#039;adresse indiquée qu&#039;elle soit absolue ou relative ne sera prise en compte qu&#039;en fonction du drapeau d&#039;état testé.<br /> <br /> Cela correspond à des instructions du type:<br /> IF CarryFlag THEN JUMP Addr<br /> IF NOT ZeroFlag THEN JUMP +n<br /> <br /> === Manipulation de la pile ===<br /> La plupart des processeurs fonctionnent avec une pile. En plus des instructions lié à l&#039;appel de sous-programme, on peut empiler et dépiler directement. Il existe habituellement une instruction pour chaque registre du processeur.<br /> <br /> PUSH A, PULL X<br /> <br /> On peut par exemple sauvegarder en pile le registre d&#039;état, réaliser une opération quelconque, puis restaurer le registre d&#039;état depuis la pile.<br /> <br /> === La lecture de données ===<br /> La plupart des instructions de lecture affectent la valeur indiquée à l&#039;accumulateur. Il arrive également que les index puissent être également affectés directement.<br /> <br /> LOAD A, 50<br /> LOAD X, 00AF80F9<br /> <br /> === L&#039;écriture de donnée ===<br /> Il s&#039;agit de l&#039;opération inverse de la précédente. Normalement seul le contenu de l&#039;accumulateur est utilisé<br /> <br /> STORE 00AF80F9+X<br /> <br /> === Les comparaisons ====<br /> Ce type d&#039;instruction consiste à comparer la valeur de l&#039;accumulateur avec une valeur quelconque. Normalement c&#039;est le drapeau Zéro qui est affecté si les valeurs sont identiques ou non.<br /> <br /> COMP A, 10<br /> <br /> === Les opérations logiques ===<br /> J&#039;avis déjà évoqué les opérateurs logiques au niveau du bit. Ici, les opérateurs s&#039;appliquent à l&#039;ensemble du mot machine.<br /> <br /> ==== Le NON ====<br /> La valeur de chaque bit est inversé. Chaque 1 devient un zéro et réciproquement.<br /> <br /> Exemple:<br /> NOT 01101001 -&gt; 10010110<br /> <br /> ==== Le OU et le ET ====<br /> On sert sert du OU pour s&#039;assurer qu&#039;un bit en particulier soit actif, et le ET pour désactiver un bit. On parle ici de masquage.<br /> <br /> Par exemple:<br /> 00010001 OU 10001000 -&gt; 10011001<br /> 11110111 ET 00101111 -&gt; 00100111<br /> <br /> ==== Les glissements et les rotations ====<br /> Les glissements correspondent simplement à un décalage vers la gauche ou vers la droite de tous le bits du mot. Le bit ajouté est toujours à zéro. Le plus enlevé est perdu. Il peut arriver qu&#039;il soit stocké dans la retenue.<br /> Ces instructions correspondent en réalité à une multiplication ou une division entière par 2 (deux). Comme cette instructions est beaucoup plus rapide que les instructions arithmétique, les algorithmes qui s&#039;appuie sur le divisions et multiplications par deux sont particulièrement efficaces.<br /> <br /> La rotation est un raffinement du glissement en prenant en compte le bit qui sort. Il est alors réintroduit dans le bit ajouté lors du glissement.<br /> <br /> === Les opérateurs arithmétiques ===<br /> Les instructions les plus simples sont les opérations d&#039;incrémentation et de décrémentation. Il s&#039;agit d&#039;ajouter ou retirer 1 à la valeur du registre. L&#039;accumulateur et les registres d&#039;index sont concernés.<br /> <br /> Ensuite nous avons les additions et les soustractions et puis c&#039;est tout.<br /> <br /> Certains processeurs complexes incluent également la multiplication et la division entière.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Processeur&diff=23 2022-09-01T13:53:42Z

<p>Guillaume : Page créée avec « Le processeur est la partie centrale d&#039;un ordinateur. C&#039;est lui qui exécute les instructions données par un programme. Les processeur sont tous différents, mais ils ont… »</p> <hr /> <div>Le processeur est la partie centrale d&#039;un ordinateur. C&#039;est lui qui exécute les instructions données par un programme.<br /> Les processeur sont tous différents, mais ils ont des caractéristiques communes.<br /> <br /> Mais comment ça marche ?<br /> <br /> == Les registres ==<br /> Tout d&#039;abord le processeur utilise des registres dans lequel il stocke les résultats des instructions et lui permettent d&#039;aller chercher les données nécessaire à l&#039;instruction à exécuter.<br /> <br /> === Le pointeur d&#039;instruction (PC) ===<br /> Le pointeur d&#039;instruction indique l&#039;adresse de la prochaine instruction à exécuter. Après l&#039;exécution de l&#039;instruction il avance d&#039;autant de mots que l&#039;instruction occupe. Les instructions les plus élémentaires ne nécessitent qu&#039;un mot alors que des instructions plus complexe en occupent plus.<br /> <br /> Il arrive que le pointeur d&#039;instruction soit accompagné d&#039;un pointeur de segment mémoire lorsque la taille du mot machine est insuffisante pour adresser l&#039;ensemble de la mémoire.<br /> <br /> === Le registre d&#039;état (SR) ===<br /> Le registre d&#039;état recense les différents drapeaux d&#039;état qui sont altérés en fonction des instructions. <br /> Parmi ces drapeaux nous avons:<br /> * La retenue (carry flag)<br /> * Le dépassement (overflow): activé lorsqu&#039;un calcul dépasse la capacité d&#039;un mot machine.<br /> * Le zéro (zero flag): Change d&#039;état en fonction des instructions de comparaison.<br /> * Le négatif : activé lorsque le résultat d&#039;une instruction est une valeur négative<br /> <br /> === L&#039;accumulateur (A) ===<br /> Il s&#039;agit du registre principal pour les opérations arithmétiques et logique.<br /> <br /> === Le pointeur de pile (SP) ===<br /> La pile peut servir à stocker des résultats intermédiaires de calculs, mais également à stocker les adresses de retour pour les instructions d&#039;appel.<br /> <br /> === Les index (X, Y) ===<br /> La valeur en mémoire est récupérée ou stockée à l&#039;emplacement mémoire indiqué en décalant de la valeur de l&#039;index. Nous verrons plus qu&#039;il existe différents adressages indexés.<br /> <br /> == Les adressages ==<br /> Le processeur à besoin de consulter des données et de stocker le résultat des instructions. Pour cela il dispose de différents stratégies d&#039;adressage.<br /> J&#039;ai ajouté des exemples de ce que donne les différents mode d&#039;adressage. Pour cela j&#039;utilise la convention suivante:<br /> * A : accumulateur<br /> * PC : pointeur d&#039;instruction<br /> * Addr : adresse indiquée en opérande de l&#039;instruction<br /> * X : index<br /> * n : opérande direct<br /> * Mem[...] : indique une valeur en mémoire à l&#039;emplacement indiqué.<br /> * s : taille de l&#039;instruction avec ses opérandes.<br /> <br /> === L&#039;adressage implicite ===<br /> Certaines instructions comme par exemple l&#039;empilement ou le dépilement n&#039;ont pas besoin de définir une adresse. Dans ce cas elle est implicite<br /> <br /> === Adressage immédiat ===<br /> La donnée est un argument de l&#039;instruction.<br /> <br /> A &lt;- n<br /> <br /> === Adressage direct ===<br /> L&#039;instruction va chercher directement la valeur à l&#039;emplacement mémoire indiqué dans l&#039;instruction.<br /> <br /> A &lt;- Mem[Addr]<br /> <br /> === Adressage absolu ===<br /> Lors d&#039;instruction de saut on indique l&#039;adresse de destination.<br /> <br /> PC &lt;- Addr<br /> <br /> === Adressage relatif ===<br /> On indique ici une adresse qui correspond au pointeur d&#039;instruction plus un nombre de mots défini en argument. Ce mode d&#039;adressage est essentiellement utilisé dans instructions de saut conditionnel.<br /> <br /> PC &lt;- PC + n + s<br /> <br /> A &lt;- Mem[PC + n]<br /> <br /> === Adressage indirect ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire indiqué l&#039;adresse où il faut lire la donnée.<br /> A &lt;- Mem[Mem[Addr]]<br /> <br /> === Adressage indexé ===<br /> L&#039;instruction lit à l&#039;emplacement mémoire en ajoutant la valeur de l&#039;index. Les adressage indexés sont de différentes natures.<br /> <br /> L&#039;adressage direct indexé: il s&#039;agit de lire à l&#039;emplacement mémoire indiqué par l&#039;opérande augmenté de la valeur de l&#039;index.<br /> <br /> A &lt;- Mem[Addr + X]<br /> <br /> L&#039;adressage indirect pré-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr + X]]<br /> <br /> L&#039;adressage indirect post-indexé:<br /> <br /> A &lt;- Mem[Mem[Addr] + X]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Num%C3%A9ration&diff=22 2022-08-31T15:36:11Z

<p>Guillaume : </p> <hr /> <div>Les système de numération<br /> <br /> == Le binaire ==<br /> Le processeur en lui-même ne gère que des bits. On dit qu&#039;il utilise le système binaire. <br /> On résume souvent au zéro (0) et au un (1) pour distinguer les deux états. Ceci est bien pratique pour réaliser des calculs.<br /> Toutefois on parlerait plutôt d&#039;état actif et d&#039;état repos. On associe le 1 à l&#039;état actif et le 0 à l&#039;état repos.<br /> <br /> Par exemple :<br /> * La porte serait ouverte ou fermée<br /> * La lumière serait allumée ou éteinte<br /> * Le niveau de l&#039;eau serait haut ou bas<br /> * etc.<br /> <br /> Une algèbre existe pour manipuler et combiner ces valeurs. Il s&#039;agit de l&#039;algèbre de Boole.<br /> <br /> A là base il existe trois opérateurs: le ET, le OU et le NON. <br /> D&#039;autres opérateurs existent mais en réalité ils peuvent être construit à partir des 3 précédents: XOU ou OU exclusif, NAND ou NOT AND, IMP ou implication.<br /> <br /> === Le ET logique ===<br /> La sortie du ET est vraie si et seulement si les 2 entrées sont vraies.<br /> <br /> Il est souvent noté par le point.<br /> <br /> === Le OU logique ===<br /> La sortie du OU est vraie si et seulement si l&#039;une des 2 entrées au moins est vraie.<br /> <br /> Il est souvent noté par le signe plus (+).<br /> <br /> === Le NON logique ===<br /> La sortie du NON est toujours l&#039;opposé de l&#039;entrée.<br /> <br /> Il est représenté par une barre horizontale au-dessus de l&#039;expression.<br /> <br /> == Les entiers ==<br /> Une succession de 0 et de 1 c&#039;est bien joli, mais ce n&#039;est pas trop parlant pour un humain qui à l&#039;habitude de manipuler les nombres en base décimale.<br /> <br /> Pour stocker des nombre entiers nous utilisons des regroupements de bits:<br /> * le tercet: permet de représenter des chiffres de 0 à 7 en base octale (base 8).<br /> * le quartet: permet de représenté un chiffre hexadécimal de 0 à F (0 à 15 en décimal).<br /> * le septet: représente des nombres de 0 à 127.<br /> * l&#039;octet: représente des nombres de 0 à 255. C&#039;est souvent une unité de base utilisée avec des multiples. Il est exactement écrit avec deux chiffres hexadécimaux.<br /> <br /> Les entiers de taille plus grandes sont représenté dans des suites d&#039;octets:<br /> * l&#039;entier court (short, shortint, int16): 2 octets. De 0 à 65535.<br /> * l&#039;entier: (int, integer, int32): 4 octets. De 0 à 2^32-1.<br /> * l&#039;entier long (long, int64): 8 octets. De 0 à 2^64-1.<br /> * l&#039;entier long long, ou entier géant (bigint, int128): 16 octets. De 0 à 2^128-1.<br /> <br /> Selon les processeurs les bits sont disposés en mémoire en partant du bit le plus significatif ou bien du moins significatif. Nous parlerons ainsi de MSB pour &quot;most significant bit&quot; et LSB pour &quot;less significant bit&quot;.<br /> <br /> Le mot: il est possible que vous rencontrerez ce terme dans de la documentation informatique. Il s&#039;agit ici du mot machine. Il s&#039;agit du nombre le plus grand qu&#039;un processeur soit capable de manipuler à chaque instruction élémentaire. Ainsi un processeur de 32 bits est capable de manipuler des nombres entiers de 32 bits.<br /> <br /> == Les entiers négatifs ==<br /> Jusqu&#039;ici nous n&#039;avons parlé que des entiers positifs. Or les unités arithmétiques des processeurs sont capables de manipuler des entiers négatifs. Comment fait-on pour les représenter ?<br /> Et bien nous utilisons le bit le plus significatif pour indiquer qu&#039;un nombre est négatif (1) ou positif (0).<br /> <br /> Mais comment fait-on pour différencier les entiers avec ou sans signes ? Dans l&#039;absolu on ne sait pas faire la différence. Seul les programmes savent comment convertir ces nombres pour l&#039;afficher correctement.<br /> <br /> == L&#039;hexadécimal ==<br /> On peut parler aussi de la base 16. Les chiffres sont : 0 à 9, puis a, b, c, d, e et f. Les lettres peuvent être en minuscule ou en majuscule. Cela n&#039;a pas d&#039;importance.<br /> Cette base est très souvent employée. Elle a l&#039;avantage d&#039;être compacte, explicite et fixe. Un octet sera toujours représenté par 2 chiffres hexa.<br /> <br /> Pour convertir de l&#039;hexa vers le décimal: pour chaque chiffre on multiplie le nombre en décimal par une puissance de 16 en fonction de sa position.<br /> Exemples (le plus significatif est à gauche):<br /> * 8a: 10 + 16 * 8 = 138<br /> * af: 15 + 16 * 10 = 175<br /> * 3fea: 10 + 14 * 16 + 15 * 16 * 16 + 3 * 16 * 16 * 16 = 16362<br /> <br /> == Les nombres décimaux ==<br /> Ici nous allons retrouver différentes façons de stocker les nombre décimaux.<br /> <br /> === A virgule fixe ===<br /> Le principe est simple. En prend un nombre entier et on déplace la virgule d&#039;autant de chiffre que souhaité.<br /> Pour savoir comment est placé le séparateur décimal, seul le programme sait. Il s&#039;agit d&#039;une convention pour savoir combien de chiffres on place après la virgule.<br /> <br /> L&#039;avantage de cette façon de faire est que les additions et les soustractions sont exactes. Le principal inconvénient est qu&#039;on ne peut pas stocker des nombres très très grands. L&#039;espace de stockage est directement proportionnel au nombre de chiffres à stocker.<br /> <br /> On utilise ce format essentiellement pour la finance et la comptabilité ou la précision est importante.<br /> <br /> === A virgule flottante ===<br /> Bon là, ça se complique. L&#039;objectif de ce format est de pouvoir stocker des nombres de grande taille en prenant le moins de place possible. On utilise pour cela le format IEEE. Vous pouvez consulter la page [https://fr.wikipedia.org/wiki/IEEE_754 Wikipédia] pour plus d&#039;informations.<br /> <br /> Pour la base, dans une série d&#039;octets on stocke les informations pour reconstituer le nombre. Les différents parties sont: le signe (1 bit), la mantisse et l&#039;exposant.<br /> Vous commencer à percevoir le problème que cela pose ? Il s&#039;agit d&#039;une approximation du nombre de départ. D&#039;une part à cause de la mantisse qui perd les chiffres les moins significatifs et d&#039;autres part à cause de l&#039;exposant qui fonctionne en base 2. Ainsi des nombre comme 1, 3, ou 10 ne sont pas stockés comme tels.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Num%C3%A9ration&diff=21 2022-08-31T15:01:10Z

<p>Guillaume : </p> <hr /> <div>Les système de numération<br /> <br /> == Le binaire ==<br /> Le processeur en lui-même ne gère que des bits. On dit qu&#039;il utilise le système binaire. <br /> On résume souvent au zéro (0) et au un (1) pour distinguer les deux états. Ceci est bien pratique pour réaliser des calculs.<br /> Toutefois on parlerait plutôt d&#039;état actif et d&#039;état repos. On associe le 1 à l&#039;état actif et le 0 à l&#039;état repos.<br /> <br /> Par exemple :<br /> * La porte serait ouverte ou fermée<br /> * La lumière serait allumée ou éteinte<br /> * Le niveau de l&#039;eau serait haut ou bas<br /> * etc.<br /> <br /> Une algèbre existe pour manipuler et combiner ces valeurs. Il s&#039;agit de l&#039;algèbre de Boole.<br /> <br /> A là base il existe trois opérateurs: le ET, le OU et le NON. <br /> D&#039;autres opérateurs existent mais en réalité ils peuvent être construit à partir des 3 précédents: XOU ou OU exclusif, NAND ou NOT AND, IMP ou implication.<br /> <br /> === Le ET logique ===<br /> La sortie du ET est vraie si et seulement si les 2 entrées sont vraies.<br /> <br /> Il est souvent noté par le point.<br /> <br /> === Le OU logique ===<br /> La sortie du OU est vraie si et seulement si l&#039;une des 2 entrées au moins est vraie.<br /> <br /> Il est souvent noté par le signe plus (+).<br /> <br /> === Le NON logique ===<br /> La sortie du NON est toujours l&#039;opposé de l&#039;entrée.<br /> <br /> Il est représenté par une barre horizontale au-dessus de l&#039;expression.<br /> <br /> == Les entiers ==<br /> Une succession de 0 et de 1 c&#039;est bien joli, mais ce n&#039;est pas trop parlant pour un humain qui à l&#039;habitude de manipuler les nombres en base décimale.<br /> <br /> Pour stocker des nombre entiers nous utilisons des regroupements de bits:<br /> * le tercet: permet de représenter des chiffres de 0 à 7 en base octale (base 8).<br /> * le quartet: permet de représenté un chiffre hexadécimal de 0 à F (0 à 15 en décimal).<br /> * le septet: représente des nombres de 0 à 127.<br /> * l&#039;octet: représente des nombres de 0 à 255. C&#039;est souvent une unité de base utilisée avec des multiples. Il est exactement écrit avec deux chiffres hexadécimaux.<br /> <br /> Les entiers de taille plus grandes sont représenté dans des suites d&#039;octets:<br /> * l&#039;entier court (short, shortint, int16): 2 octets. De 0 à 65535.<br /> * l&#039;entier: (int, integer, int32): 4 octets. De 0 à 2^32-1.<br /> * l&#039;entier long (long, int64): 8 octets. De 0 à 2^64-1.<br /> * l&#039;entier long long, ou entier géant (bigint, int128): 16 octets. De 0 à 2^128-1.<br /> <br /> Selon les processeurs les bits sont disposés en mémoire en partant du bit le plus significatif ou bien du moins significatif. Nous parlerons ainsi de MSB pour &quot;most significant bit&quot; et LSB pour &quot;less significant bit&quot;.<br /> <br /> Le mot: il est possible que vous rencontrerez ce terme dans de la documentation informatique. Il s&#039;agit ici du mot machine. Il s&#039;agit du nombre le plus grand qu&#039;un processeur soit capable de manipuler à chaque instruction élémentaire. Ainsi un processeur de 32 bits est capable de manipuler des nombres entiers de 32 bits.<br /> <br /> == Les entiers négatifs ==<br /> Jusqu&#039;ici nous n&#039;avons parlé que des entiers positifs. Or les unités arithmétiques des processeurs sont capables de manipuler des entiers négatifs. Comment fait-on pour les représenter ?<br /> Et bien nous utilisons le bit le plus significatif pour indiquer qu&#039;un nombre est négatif (1) ou positif (0).<br /> <br /> Mais comment fait-on pour différencier les entiers avec ou sans signes ? Dans l&#039;absolu on ne sait pas faire la différence. Seul les programmes savent comment convertir ces nombres pour l&#039;afficher correctement.<br /> <br /> == L&#039;hexadécimal ==<br /> On peut parler aussi de la base 16. Les chiffres sont : 0 à 9, puis a, b, c, d, e et f. Les lettres peuvent être en minuscule ou en majuscule. Cela n&#039;a pas d&#039;importance.<br /> Cette base est très souvent employée. Elle a l&#039;avantage d&#039;être compacte, explicite et fixe. Un octet sera toujours représenté par 2 chiffres hexa.<br /> <br /> Pour convertir de l&#039;hexa vers le décimal: pour chaque chiffre on multiplie le nombre en décimal par une puissance de 16 en fonction de sa position.<br /> Exemples (le plus significatif est à gauche):<br /> * 8a: 10 + 16 * 8 = 138<br /> * af: 15 + 16 * 10 = 175<br /> * 3fea: 10 + 14 * 16 + 15 * 16 * 16 + 3 * 16 * 16 * 16 = 16362</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Num%C3%A9ration&diff=20 2022-08-31T14:58:11Z

<p>Guillaume : Comment les ordinateurs gèrent les nombres</p> <hr /> <div>== Les système de numération ==<br /> <br /> === Le binaire ===<br /> Le processeur en lui-même ne gère que des bits. On dit qu&#039;il utilise le système binaire. <br /> On résume souvent au zéro (0) et au un (1) pour distinguer les deux états. Ceci est bien pratique pour réaliser des calculs.<br /> Toutefois on parlerait plutôt d&#039;état actif et d&#039;état repos. On associe le 1 à l&#039;état actif et le 0 à l&#039;état repos.<br /> <br /> Par exemple :<br /> * La porte serait ouverte ou fermée<br /> * La lumière serait allumée ou éteinte<br /> * Le niveau de l&#039;eau serait haut ou bas<br /> * etc.<br /> <br /> Une algèbre existe pour manipuler et combiner ces valeurs. Il s&#039;agit de l&#039;algèbre de Boole.<br /> <br /> A là base il existe trois opérateurs: le ET, le OU et le NON. <br /> D&#039;autres opérateurs existent mais en réalité ils peuvent être construit à partir des 3 précédents: XOU ou OU exclusif, NAND ou NOT AND, IMP ou implication.<br /> <br /> ==== Le ET logique ====<br /> La sortie du ET est vraie si et seulement si les 2 entrées sont vraies.<br /> <br /> Il est souvent noté par le point.<br /> <br /> ==== Le OU logique ====<br /> La sortie du OU est vraie si et seulement si l&#039;une des 2 entrées au moins est vraie.<br /> <br /> Il est souvent noté par le signe plus (+).<br /> <br /> ==== Le NON logique =====<br /> La sortie du NON est toujours l&#039;opposé de l&#039;entrée.<br /> <br /> Il est représenté par une barre horizontale au-dessus de l&#039;expression.<br /> <br /> === Les entiers ===<br /> Une succession de 0 et de 1 c&#039;est bien joli, mais ce n&#039;est pas trop parlant pour un humain qui à l&#039;habitude de manipuler les nombres en base décimale.<br /> <br /> Pour stocker des nombre entiers nous utilisons des regroupements de bits:<br /> - le tercet: permet de représenter des chiffres de 0 à 7 en base octale (base 8).<br /> - le quartet: permet de représenté un chiffre hexadécimal de 0 à F (0 à 15 en décimal).<br /> - le septet: représente des nombres de 0 à 127.<br /> - l&#039;octet: représente des nombres de 0 à 255. C&#039;est souvent une unité de base utilisée avec des multiples. Il est exactement écrit avec deux chiffres hexadécimaux.<br /> <br /> Les entiers de taille plus grandes sont représenté dans des suites d&#039;octets:<br /> - l&#039;entier court (short, shortint, int16): 2 octets. De 0 à 65535.<br /> - l&#039;entier: (int, integer, int32): 4 octets. De 0 à 2^32-1.<br /> - l&#039;entier long (long, int64): 8 octets. De 0 à 2^64-1.<br /> - l&#039;entier long long, ou entier géant (bigint, int128): 16 octets. De 0 à 2^128-1.<br /> <br /> Selon les processeurs les bits sont disposés en mémoire en partant du bit le plus significatif ou bien du moins significatif. Nous parlerons ainsi de MSB pour &quot;most significant bit&quot; et LSB pour &quot;less significant bit&quot;.<br /> <br /> Le mot: il est possible que vous rencontrerez ce terme dans de la documentation informatique. Il s&#039;agit ici du mot machine. Il s&#039;agit du nombre le plus grand qu&#039;un processeur soit capable de manipuler à chaque instruction élémentaire. Ainsi un processeur de 32 bits est capable de manipuler des nombres entiers de 32 bits.<br /> <br /> === Les entiers négatifs ===<br /> Jusqu&#039;ici nous n&#039;avons parlé que des entiers positifs. Or les unités arithmétiques des processeurs sont capables de manipuler des entiers négatifs. Comment fait-on pour les représenter ?<br /> Et bien nous utilisons le bit le plus significatif pour indiquer qu&#039;un nombre est négatif (1) ou positif (0).<br /> <br /> Mais comment fait-on pour différencier les entiers avec ou sans signes ? Dans l&#039;absolu on ne sait pas faire la différence. Seul les programmes savent comment convertir ces nombres pour l&#039;afficher correctement.<br /> <br /> === L&#039;hexadécimal ===<br /> On peut parler aussi de la base 16. Les chiffres sont : 0 à 9, puis a, b, c, d, e et f. Les lettres peuvent être en minuscule ou en majuscule. Cela n&#039;a pas d&#039;importance.<br /> Cette base est très souvent employée. Elle a l&#039;avantage d&#039;être compacte, explicite et fixe. Un octet sera toujours représenté par 2 chiffres hexa.<br /> <br /> Pour convertir de l&#039;hexa vers le décimal: pour chaque chiffre on multiplie le nombre en décimal par une puissance de 16 en fonction de sa position.<br /> Exemples (le plus significatif est à gauche):<br /> - 8a: 10 + 16 * 8 = 138<br /> - af: 15 + 16 * 10 = 175<br /> - 3fea: 10 + 14 * 16 + 15 * 16 * 16 + 3 * 16 * 16 * 16 = 16362</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Notions&diff=19 2022-08-31T13:44:55Z

<p>Guillaume : Page créée avec « == Notions de base == * Architecture générale d&#039;un ordinateur Quels sont les principaux éléments indispensables pour avoir un ordinateur fonctionnel… »</p> <hr /> <div>== Notions de base ==<br /> <br /> * [[Architecture|Architecture générale d&#039;un ordinateur]] Quels sont les principaux éléments indispensables pour avoir un ordinateur fonctionnel<br /> * [[Stockage|Unités de stockage]] Les différent types d&#039;unité de stockage des données<br /> * [[Processeur|Le fonctionnement général d&#039;un processeur]] Les principaux registres et instructions<br /> * [[Numération|Systèmes de numération]] On détaille ici les différentes façon de stocker et de manipuler les nombres</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Syst%C3%A8mes_d%27exploitation&diff=18 2022-07-21T15:32:41Z

<p>Guillaume : Création de la page</p> <hr /> <div>Un système d&#039;exploitation (SE) permet d&#039;exploiter ... un ordinateur.<br /> <br /> Son rôle essentiel consiste à charger en mémoire vive différents programmes de gestion des périphériques appelés pilote. Il s&#039;agit d&#039;une couche intermédiaire entre une application et la machine qui la fait tourner.<br /> <br /> C&#039;est pourquoi un programme conçu pour un SE particulier ne peut pas tourner sur un autre. Il existe toutefois des exceptions.<br /> <br /> Il existe aujourd&#039;hui deux principaux types de système d&#039;exploitation: Windows et Linux.<br /> <br /> Certains me diront: &lt;quote&gt;Mais tu ne parles pas d&#039;iOS ou d&#039;Android !!&lt;/quote&gt;.<br /> <br /> J&#039;y viens.<br /> <br /> Quand on parle de groupes de systèmes d&#039;exploitation, on se base sur son noyau. Le reste c&#039;est le l&#039;enrobage avec des outils qui permettent de se servir efficacement d&#039;un ordinateur.<br /> <br /> Et, au regret de vous décevoir, Android et iOS sont basés sur un noyau Linux, même si c&#039;est une version modifiée. <br /> <br /> Je ne parle pas des versions antérieures des systèmes d&#039;exploitation qui on eu cours chez Apple.<br /> <br /> D&#039;autres systèmes d&#039;exploitation ont existés par le passé. Il est possible que j&#039;en cite quelques un mais je ne m&#039;étendrai pas là dessus. Dans la mesure où j&#039;en ai un, je mettrai une référence externe.<br /> <br /> == Windows ==<br /> Au jour ou j&#039;écris ces lignes, on en est à Windows 11. Le plus courant est la version 64 bits. Il existe en plusieurs distributions selon le public visé:<br /> * Familiale: convient à la plupart des utilisateurs particuliers.<br /> * Professionnelle: contient des outils complémentaires très utiles aux professionnels de l&#039;informatique. Le plus notable est la virtualisation.<br /> * Serveur: L&#039;interface est spécialement orientée vers la création et l&#039;administration de serveurs.<br /> <br /> Ces distributions sont ensuite déclinées en fonction du processeur cible: ARM, x86, etc.<br /> <br /> Au tout début, Windows était simplement une surcouche graphique au dessus du système MS-DOS. Les versions 2 et 3 ont eu leur succès jusqu&#039;à la version 3.11. Il s&#039;agissait d&#039;un système 16 bits. Il existait une extension 32 bits, mais ça ne fonctionnait pas très bien.<br /> <br /> C&#039;est alors que la révolution est arrivée avec Windows 95 qui était un système d&#039;exploitation nativement purement graphique. Un peu plus tard, Microsoft avait crée Windows NT qui était essentiellement destiné aux professionnels. Ces deux branches ont fusionnées avec l&#039;avènement de Windows 2000. Les évolutions majeures suivantes ont été Windows XP, Windows 7, puis enfin le 8 qui s&#039;est amélioré avec le 10 et le 11. <br /> <br /> Windows 9 n&#039;a jamais existé commercialement. Et je me demande même s&#039;il a vraiment existé à l&#039;état de projet.<br /> <br /> Les système d&#039;organisation des fichiers sur les disques durs ont été FAT, FAT32 et NTFS. Le système FAT (et le FAT32) limitait les noms de fichier à 8 caractères et 3 pour l&#039;extension. C&#039;est pourquoi pendant longtemps, pour autoriser les noms longs, Windows utilisait une table de correspondance entre un nom long et un nom court. Ainsi, le nom court ressemblait souvent à &quot;FICHIE~1.TXT&quot; pour &quot;Fichier long.txt&quot;.<br /> <br /> Windows doit son succès à plusieurs circonstances. La première, venait du fait qu&#039;il était vendu préinstallé sur tous les PC vendus. Aujourd&#039;hui c&#039;est encore un peu le cas. Le deuxième, était son composant DirectX qui facilitait grandement la création de jeux vidéos.<br /> <br /> === Linux ===<br /> Ce système d&#039;exploitation est créé au départ par Linus Torvald. Il a remplacé progressivement le système Unix, dont beaucoup d&#039;outils ont été repris.<br /> <br /> Mais le noyau en l&#039;état est inutilisable. Il faut d&#039;autres outils pour l&#039;utiliser efficacement. Les interfaces de ligne de commande (shells) sont des adaptations des version qui existaient sur Unix. C&#039;est pourquoi l&#039;organisation des dossiers ainsi que la façon de nommer les chemins sont très similaires. C&#039;est ainsi que sont apparues les distributions Linux.<br /> <br /> La force principale de Linux vient du fait qu&#039;il est nativement multi-utilisateurs et multi-tâche. C&#039;est pourquoi on l&#039;a principalement dédié à la création de serveurs. Son autre force est que le code source est libre, c&#039;est à dire que n&#039;importe qui peut lire comment il est écrit mais également contribuer à son évolution.<br /> <br /> Aujourd&#039;hui il existe tellement de distributions différentes qu&#039;il serait difficile d&#039;en faire une énumération. Chacun dispose de ses propres caractéristiques. Pour se faire une idée, le mieux est de se rendre sur [https://distrowatch.com/ distrowatch].<br /> <br /> Il est possible de se faire sont système Linux sur mesure. Cela implique de compiler tous les outils nécessaire avant de les installer. Les courageux peuvent se rendre sur le site de [https://www.linuxfromscratch.org/ Linux from Scratch] et suivre les instructions qui sont données. En revanche il faut avoir déjà un ordinateur avec un SE fonctionnel pour compiler la suite d&#039;outils qui serviront à l&#039;installation progressive du système d&#039;exploitation.</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=17 2022-07-21T14:21:09Z

<p>Guillaume : </p> <hr /> <div>Bienvenue sur ce wiki destiné au monde de la programmation et des notions qui gravitent autour.<br /> <br /> Au menu:<br /> * [[algorithmique|Les algorithmes]]<br /> * [[Paradigmes|Les paradigmes et concepts]]<br /> * [[Languages|Les langages de programmation]]<br /> * [[Notions|Notions de base sur la programmation et l&#039;informatique]]<br /> * [[Systèmes d&#039;exploitation|Les systèmes d&#039;exploitation]]<br /> * [[Outils|Les outils du développeur]]<br /> * [[Concepts avancés]]<br /> <br /> &lt;!-- <br /> [[Ancien accueil]]<br /> --&gt;</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Ancien_accueil&diff=16 2022-07-21T14:04:59Z

<p>Guillaume : Page créée avec « &lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt; Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’info… »</p> <hr /> <div><br /> <br /> &lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt;<br /> <br /> Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’informations sur l’utilisation de ce logiciel de wiki.<br /> <br /> == Pour démarrer ==<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Liste des paramètres de configuration]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ Questions courantes sur MediaWiki]<br /> * [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Liste de discussion sur les distributions de MediaWiki]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Adaptez MediaWiki dans votre langue]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Apprendre comment lutter contre le pourriel dans votre wiki]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=15 2022-07-21T14:04:23Z

<p>Guillaume : </p> <hr /> <div>Bienvenue sur ce wiki destiné au monde de la programmation et des notions qui gravitent autour.<br /> <br /> Au menu:<br /> * [[algorithmique|Les algorithmes]]<br /> * Les paradigmes et concepts<br /> * Les langages de programmation<br /> * Notions de base sur la programmation et l&#039;informatique<br /> * Les systèmes d&#039;exploitation<br /> * Les outils du développeur<br /> * Concepts avancés<br /> <br /> [[Ancien accueil]]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=14 2022-07-21T14:01:55Z

<p>Guillaume : </p> <hr /> <div>Bienvenue sur ce wiki destiné au monde de la programmation et des notions qui gravitent autour.<br /> <br /> Au menu:<br /> * [[algorithmique|Les algorithmes]]<br /> * Les paradigmes et concepts<br /> * Les langages de programmation<br /> * Notions de base sur la programmation et l&#039;informatique<br /> * Les systèmes d&#039;exploitation<br /> * Les outils du développeur<br /> * Concepts avancés<br /> <br /> <br /> <br /> <br /> &lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt;<br /> <br /> Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’informations sur l’utilisation de ce logiciel de wiki.<br /> <br /> == Pour démarrer ==<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Liste des paramètres de configuration]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ Questions courantes sur MediaWiki]<br /> * [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Liste de discussion sur les distributions de MediaWiki]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Adaptez MediaWiki dans votre langue]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Apprendre comment lutter contre le pourriel dans votre wiki]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=13 2022-07-21T14:01:36Z

<p>Guillaume : </p> <hr /> <div>Bienvenue sur ce wiki destiné au monde de la programmation et des notions qui gravitent autour.<br /> <br /> Au menu:<br /> * [[algorithmique|Les algorithmes]]<br /> * Les paradigmes et concepts<br /> * Les langages de programmation<br /> * Notions de base sur la programmation et l&#039;informatique<br /> * Les systèmes d&#039;exploitation<br /> * Les outils du développeur<br /> * Concepts avancés<br /> <br /> &lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt;<br /> <br /> Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’informations sur l’utilisation de ce logiciel de wiki.<br /> <br /> == Pour démarrer ==<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Liste des paramètres de configuration]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ Questions courantes sur MediaWiki]<br /> * [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Liste de discussion sur les distributions de MediaWiki]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Adaptez MediaWiki dans votre langue]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Apprendre comment lutter contre le pourriel dans votre wiki]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=12 2022-07-21T13:55:53Z

<p>Guillaume : </p> <hr /> <div>&lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt;<br /> <br /> Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’informations sur l’utilisation de ce logiciel de wiki.<br /> <br /> Au menu:<br /> * [[algorithmique|Les algorithmes]]<br /> * Les langages de programmation<br /> * Notions de base sur la programmation et l&#039;informatique<br /> * Concepts avancés<br /> <br /> == Pour démarrer ==<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Liste des paramètres de configuration]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ Questions courantes sur MediaWiki]<br /> * [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Liste de discussion sur les distributions de MediaWiki]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Adaptez MediaWiki dans votre langue]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Apprendre comment lutter contre le pourriel dans votre wiki]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Syntaxe_algorithme&diff=11 2022-07-21T13:54:54Z

<p>Guillaume : </p> <hr /> <div>== Introduction ==<br /> La casse des caractères n&#039;a pas d&#039;importance pour les mots-clés. En règle générale, ils sont écris en majuscule.<br /> <br /> Toutefois le style dépend de la sensibilité de chacun. Personnellement j&#039;aime bien utiliser le tout-minuscule.<br /> <br /> == Règles générales ==<br /> Chaque ligne contient une instruction. Elle se termine avec le saut de ligne. <br /> <br /> Certains mots-clés sont des ouvertures de bloc. La fermeture est signalée par le mot-clé &quot;FIN&quot; suivi du mot-clé d&#039;ouverture. Exemple:<br /> SI ....<br /> # Instructions<br /> FIN SI<br /> <br /> L&#039;algorithme commence toujours par le mot-clé &quot;ALGORITHME&quot; suivi du nom.<br /> <br /> == Les commentaires ==<br /> Il y a deux formes de commentaires: la ligne simple et le multiligne.<br /> <br /> La ligne simple commence par le symbole &quot;#&quot; et se termine en fin de ligne.<br /> <br /> Le multiligne commence par la combinaison de symboles &quot;&#039;&#039;&#039;/*&#039;&#039;&#039;&quot; et se termine par &quot;&#039;&#039;&#039;*/&#039;&#039;&#039;&quot;. Tant que le symbole de terminaison le texte peut se retrouver sur plusieurs lignes.<br /> <br /> Exemple:<br /> # Commentaire sur une seule ligne<br /> <br /> /* Ce commentaire <br /> se développe sur<br /> plusieurs lignes */<br /> <br /> Les commentaires peuvent se retrouver avant le début et après la fin de l&#039;algorithme.<br /> <br /> J&#039;ai pris pour habitude de mettre en fin le résultat attendu.<br /> <br /> == Les types de données ==<br /> === Les types intrinsèques ===<br /> Il s&#039;agit essentiellement des types de base. Il servent à construire de nouveaux types de données grâce aux instructions de construction de type.<br /> <br /> * entier: il correspond à l&#039;ensemble des entiers relatifs. Si c&#039;est vraiment nécessaire, on peut utiliser une des alternatives qui précise la taille: octet, entier16, entier32, entier64.<br /> * nombre, réel, flottant: il s&#039;agit de l&#039;ensemble des réels. La précision n&#039;est pas donnée. Le séparateur décimal est le point.<br /> * décimal(taille, précision): il correspond à un sous-ensemble des décimaux. Ils sont indispensable pour conserver une précision des données. <br /> C&#039;est souvent indispensable pour tout ce qui concerne la finance et la comptabilité.<br /> * caractère: contient un caractère possible parmi l&#039;ensemble des jeux de caractères. Les valeurs sont écrites entre 2 apostrophes &lt;code&gt;&#039;a&#039;&lt;/code&gt;<br /> * texte, chaine, chaine(longueur): Il s&#039;agit d&#039;une chaine de caractères. La dernière forme précise la taille maximale. Les valeurs sont écrites entre deux guillemets &lt;code&gt;&quot;du texte&quot;&lt;/code&gt;<br /> * quelconque: Il remplace n&#039;importe quel type de données. Attention toutefois à ne pas en abuser !!<br /> * date, heure, dateheure : ces types permettent de définir des valeurs liées au temps qui passe. L&#039;initialisation de ces valeurs utilise le format courant utilisé en France. <br /> C&#039;est à dire &quot;JJ/MM/AAAA&quot; pour la date et &quot;HH:MM:SS&quot; pour l&#039;heure. Ils sont écrits dans une chaine de caractère.<br /> <br /> === Les constructions ===<br /> Les constructions se basent sur les types intrinsèques pour définir de nouveaux types.<br /> <br /> ==== Les tableaux ====<br /> Un tableau regroupe dans une même structure plusieurs valeurs qu&#039;on peut accéder par un index.<br /> &lt;code&gt;TABLEAU DE 5 ENTIER&lt;/code&gt;<br /> <br /> ==== L&#039;énumération ====<br /> L&#039;énumération définit une liste de symboles qui introduisent une abstraction. On les associe en général à une série de constantes regroupées sous un même concept.<br /> <br /> ENUMERATION JourSemaine<br /> Lundi<br /> Mardi<br /> Mercredi<br /> ...<br /> FIN ENUMERATION<br /> <br /> ==== La structure ====<br /> Dans une structure on stocke plusieurs champs de données de nature hétérogènes.<br /> <br /> STRUCTURE RendezVous<br /> date: DATE<br /> lieu: POSITION_GEOGRAPHIQUE<br /> FIN STRUCTURE<br /> <br /> ==== La classe d&#039;objet ====<br /> La classe d&#039;objet est une extension du concept de structure. En plus des données, on y ajoute des méthodes, qui sont en réalité des fonctions et des procédures encapsulées dans une structure.<br /> <br /> CLASSE Animal<br /> nom: CHAINE<br /> <br /> PROCEDURE marche()<br /> FIN PROCEDURE<br /> <br /> FIN CLASSE<br /> <br /> ==== La référence ====<br /> La référence permet d&#039;indiquer que deux variables distinctes pointent vers la même zone de stockage de la valeur.<br /> <br /> On s&#039;en sert essentiellement pour éviter de copier un trop grand nombre de données lors de l&#039;appel d&#039;une fonction ou d&#039;une procédure.<br /> Cela permet également de rendre modifiable une valeur passée en paramètres d&#039;une procédure ou d&#039;une fonction.<br /> <br /> === Les déclarations ===<br /> ==== Les variables ====<br /> Les variables sont introduites par le mot-clé &quot;VARIABLE&quot;. On y définit son nom, son type et éventuellement une valeur d&#039;initialisation. <br /> <br /> Si le type n&#039;est pas mis, alors c&#039;est l&#039;expression d&#039;initialisation qui détermine le type. S&#039;il n&#039;y a pas d&#039;initialisation, c&#039;est alors le type quelconque qui est pris par défaut.<br /> <br /> VARIABLE mon_nom : CHAINE = &quot;John Doe&quot;<br /> <br /> Il n&#039;est pas nécessaire de répéter le mot clé &quot;VARIABLE&quot; pour chaque ligne de déclaration. Elle termine normalement avec la prochaine instruction qui commence par un mot-clé.<br /> <br /> VARIABLE<br /> mon_métier = &quot;Développeur&quot;<br /> mon_salaire: Nombre<br /> <br /> ==== Les constantes ====<br /> Lorsqu&#039;on a besoin de définir une valeur de nature constante et qui est reprise à plusieurs endroit. On définit une constante. Elles sont introduites avec le mot-clé &quot;CONSTANTE&quot; et l&#039;écriture est similaire aux variables.<br /> <br /> Le type n&#039;est pas indispensable, mais l&#039;expression d&#039;initialisation est obligatoire<br /> <br /> CONSTANTE<br /> nombre_de_jours: entier = 7<br /> nombre_de_mois = 12</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Syntaxe_algorithme&diff=10 2022-07-21T13:53:14Z

<p>Guillaume : Page créée avec « == Introduction == La casse des caractères n&#039;a pas d&#039;importance pour les mots-clés. En règle générale, ils sont écris en majuscule. Toutefois le style dépend de la… »</p> <hr /> <div>== Introduction ==<br /> La casse des caractères n&#039;a pas d&#039;importance pour les mots-clés. En règle générale, ils sont écris en majuscule.<br /> <br /> Toutefois le style dépend de la sensibilité de chacun. Personnellement j&#039;aime bien utiliser le tout-minuscule.<br /> <br /> == Règles générales ==<br /> Chaque ligne contient une instruction. Elle se termine avec le saut de ligne. <br /> <br /> Certains mots-clés sont des ouvertures de bloc. La fermeture est signalée par le mot-clé &quot;FIN&quot; suivi du mot-clé d&#039;ouverture. Exemple:<br /> SI ....<br /> # Instructions<br /> FIN SI<br /> <br /> L&#039;algorithme commence toujours par le mot-clé &quot;ALGORITHME&quot; suivi du nom.<br /> <br /> == Les commentaires ==<br /> Il y a deux formes de commentaires: la ligne simple et le multiligne.<br /> <br /> La ligne simple commence par le symbole &quot;#&quot; et se termine en fin de ligne.<br /> <br /> Le multiligne commence par la combinaison de symboles &quot;&#039;&#039;&#039;/*&#039;&#039;&#039;&quot; et se termine par &quot;&#039;&#039;&#039;*/&#039;&#039;&#039;&quot;. Tant que le symbole de terminaison le texte peut se retrouver sur plusieurs lignes.<br /> <br /> Exemple:<br /> # Commentaire sur une seule ligne<br /> <br /> /* Ce commentaire <br /> se développe sur<br /> plusieurs lignes */<br /> <br /> Les commentaires peuvent se retrouver avant le début et après la fin de l&#039;algorithme.<br /> <br /> J&#039;ai pris pour habitude de mettre en fin le résultat attendu.<br /> <br /> == Les types de données ==<br /> === Les types intrinsèques ===<br /> Il s&#039;agit essentiellement des types de base. Il servent à construire de nouveaux types de données grâce aux instructions de construction de type.<br /> <br /> * entier: il correspond à l&#039;ensemble des entiers relatifs. Si c&#039;est vraiment nécessaire, on peut utiliser une des alternatives qui précise la taille: octet, entier16, entier32, entier64.<br /> * nombre, réel, flottant: il s&#039;agit de l&#039;ensemble des réels. La précision n&#039;est pas donnée. Le séparateur décimal est le point.<br /> * décimal(taille, précision): il correspond à un sous-ensemble des décimaux. Ils sont indispensable pour conserver une précision des données. <br /> C&#039;est souvent indispensable pour tout ce qui concerne la finance et la comptabilité.<br /> * caractère: contient un caractère possible parmi l&#039;ensemble des jeux de caractères. Les valeurs sont écrites entre 2 apostrophes &lt;code&gt;&#039;a&#039;&lt;/code&gt;<br /> * texte, chaine, chaine(longueur): Il s&#039;agit d&#039;une chaine de caractères. La dernière forme précise la taille maximale. Les valeurs sont écrites entre deux guillemets &lt;code&gt;&quot;du texte&quot;&lt;/code&gt;<br /> * quelconque: Il remplace n&#039;importe quel type de données. Attention toutefois à ne pas en abuser !!<br /> * date, heure, dateheure : ces types permettent de définir des valeurs liées au temps qui passe. L&#039;initialisation de ces valeurs utilise le format courant utilisé en France. <br /> C&#039;est à dire &quot;JJ/MM/AAAA&quot; pour la date et &quot;HH:MM:SS&quot; pour l&#039;heure. Ils sont écrits dans une chaine de caractère.<br /> <br /> === Les constructions ===<br /> Les constructions se basent sur les types intrinsèques pour définir de nouveaux types.<br /> <br /> === Les tableaux ===<br /> Un tableau regroupe dans une même structure plusieurs valeurs qu&#039;on peut accéder par un index.<br /> &lt;code&gt;TABLEAU DE 5 ENTIER&lt;/code&gt;<br /> <br /> ==== L&#039;énumération ====<br /> L&#039;énumération définit une liste de symboles qui introduisent une abstraction. On les associe en général à une série de constantes regroupées sous un même concept.<br /> <br /> ENUMERATION JourSemaine<br /> Lundi<br /> Mardi<br /> Mercredi<br /> ...<br /> FIN ENUMERATION<br /> <br /> ==== La structure ====<br /> Dans une structure on stocke plusieurs champs de données de nature hétérogènes.<br /> <br /> STRUCTURE RendezVous<br /> date: DATE<br /> lieu: POSITION_GEOGRAPHIQUE<br /> FIN STRUCTURE<br /> <br /> ==== La classe d&#039;objet ====<br /> La classe d&#039;objet est une extension du concept de structure. En plus des données, on y ajoute des méthodes, qui sont en réalité des fonctions et des procédures encapsulées dans une structure.<br /> <br /> CLASSE Animal<br /> nom: CHAINE<br /> <br /> PROCEDURE marche()<br /> FIN PROCEDURE<br /> <br /> FIN CLASSE<br /> <br /> ==== La référence ====<br /> La référence permet d&#039;indiquer que deux variables distinctes pointent vers la même zone de stockage de la valeur.<br /> <br /> On s&#039;en sert essentiellement pour éviter de copier un trop grand nombre de données lors de l&#039;appel d&#039;une fonction ou d&#039;une procédure.<br /> Cela permet également de rendre modifiable une valeur passée en paramètres d&#039;une procédure ou d&#039;une fonction.<br /> <br /> === Les déclarations ===<br /> ==== Les variables ====<br /> Les variables sont introduites par le mot-clé &quot;VARIABLE&quot;. On y définit son nom, son type et éventuellement une valeur d&#039;initialisation. <br /> <br /> Si le type n&#039;est pas mis, alors c&#039;est l&#039;expression d&#039;initialisation qui détermine le type. S&#039;il n&#039;y a pas d&#039;initialisation, c&#039;est alors le type quelconque qui est pris par défaut.<br /> <br /> VARIABLE mon_nom : CHAINE = &quot;John Doe&quot;<br /> <br /> Il n&#039;est pas nécessaire de répéter le mot clé &quot;VARIABLE&quot; pour chaque ligne de déclaration. Elle termine normalement avec la prochaine instruction qui commence par un mot-clé.<br /> <br /> VARIABLE<br /> mon_métier = &quot;Développeur&quot;<br /> mon_salaire: Nombre<br /> <br /> === Les constantes ===<br /> Lorsqu&#039;on a besoin de définir une valeur de nature constante et qui est reprise à plusieurs endroit. On définit une constante. Elles sont introduites avec le mot-clé &quot;CONSTANTE&quot; et l&#039;écriture est similaire aux variables.<br /> <br /> Le type n&#039;est pas indispensable, mais l&#039;expression d&#039;initialisation est obligatoire<br /> <br /> CONSTANTE<br /> nombre_de_jours: entier = 7<br /> nombre_de_mois = 12</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Algorithmique&diff=9 2022-07-21T12:37:11Z

<p>Guillaume : Page d&#039;accueil de l&#039;algorithmie</p> <hr /> <div><br /> &lt;p&gt;L&#039;algorithmie est l&#039;art de décrire une procédure pour résoudre un problème.&lt;/p&gt;<br /> <br /> &lt;p&gt;Il existe différentes façons de le faire. Celle que la plupart des gens connaissent est une recette de cuisine.&lt;/p&gt;<br /> <br /> &lt;p&gt;Pour écrire les algorithmes, j&#039;utilise un pseudo-code qui contient des mots-clés en langue française. Suivez ce lien pour le détail de [[Syntaxe algorithme|la syntaxe utilisée]]<br /> <br /> Je les ai divisés en catégories selon leur usage:<br /> * [[Manipulation de texte]]<br /> * [[Les arbres]]<br /> * [[Les tris]]<br /> * [[Les tableaux|La manipulation de tableaux]]<br /> * [[Les patrons de conceptions]]<br /> * [[Le graphisme 3D]]<br /> * [[Autres algorithmes]]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Algorithmique&diff=8 2022-07-21T12:34:18Z

<p>Guillaume : Page d&#039;accueil de l&#039;algorithmie</p> <hr /> <div><br /> &lt;p&gt;L&#039;algorithmie est l&#039;art de décrire une procédure pour résoudre un problème.&lt;/p&gt;<br /> <br /> &lt;p&gt;Il existe différentes façons de le faire. Celle que la plupart des gens connaissent est une recette de cuisine.&lt;/p&gt;<br /> <br /> Je les ai divisés en catégories selon leur usage:<br /> * [[Manipulation de texte]]<br /> * [[Les arbres]]<br /> * [[Les tris]]<br /> * [[Les tableaux|La manipulation de tableaux]]<br /> * [[Les patrons de conceptions]]<br /> * [[Le graphisme 3D]]<br /> * [[Autres algorithmes]]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Algorithmique&diff=7 2022-07-21T12:25:06Z

<p>Guillaume : Page créée avec « &lt;h2&gt;L&#039;algorithmie&lt;h2&gt; &lt;p&gt;L&#039;algorithmie est l&#039;art de décrire une procédure pour résoudre un problème.&lt;/p&gt; &lt;p&gt;Il existe différentes façons de le faire. Celle que la… »</p> <hr /> <div>&lt;h2&gt;L&#039;algorithmie&lt;h2&gt;<br /> <br /> &lt;p&gt;L&#039;algorithmie est l&#039;art de décrire une procédure pour résoudre un problème.&lt;/p&gt;<br /> <br /> &lt;p&gt;Il existe différentes façons de le faire. Celle que la plupart des gens connaissent est une recette de cuisine.&lt;/p&gt;</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=6 2022-07-21T12:16:42Z

<p>Guillaume : /* Pour démarrer */</p> <hr /> <div>&lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt;<br /> <br /> Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’informations sur l’utilisation de ce logiciel de wiki.<br /> <br /> Au menu:<br /> * Les algorithmes<br /> * Les langages de programmation<br /> * Notions de base sur la programmation et l&#039;informatique<br /> * Concepts avancés<br /> <br /> == Pour démarrer ==<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Liste des paramètres de configuration]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ Questions courantes sur MediaWiki]<br /> * [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Liste de discussion sur les distributions de MediaWiki]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Adaptez MediaWiki dans votre langue]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Apprendre comment lutter contre le pourriel dans votre wiki]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Ancien_Accueil&diff=5 2022-07-21T12:10:41Z

<p>Guillaume : Guillaume a déplacé la page Ancien Accueil vers Accueil par-dessus une redirection</p> <hr /> <div>#REDIRECTION [[Accueil]]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=4 2022-07-21T12:10:41Z

<p>Guillaume : Guillaume a déplacé la page Ancien Accueil vers Accueil par-dessus une redirection</p> <hr /> <div>&lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt;<br /> <br /> Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’informations sur l’utilisation de ce logiciel de wiki.<br /> <br /> == Pour démarrer ==<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Liste des paramètres de configuration]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ Questions courantes sur MediaWiki]<br /> * [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Liste de discussion sur les distributions de MediaWiki]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Adaptez MediaWiki dans votre langue]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Apprendre comment lutter contre le pourriel dans votre wiki]</div>

Guillaume https://wiki.lestanville.eu/index.php?title=Accueil&diff=2 2022-07-21T12:09:48Z

<p>Guillaume : Guillaume a déplacé la page Accueil vers Ancien Accueil</p> <hr /> <div>&lt;strong&gt;MediaWiki a été installé.&lt;/strong&gt;<br /> <br /> Consultez le [https://www.mediawiki.org/wiki/Special:MyLanguage/Help:Contents Guide de l’utilisateur] pour plus d’informations sur l’utilisation de ce logiciel de wiki.<br /> <br /> == Pour démarrer ==<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Configuration_settings Liste des paramètres de configuration]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ Questions courantes sur MediaWiki]<br /> * [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce Liste de discussion sur les distributions de MediaWiki]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Localisation#Translation_resources Adaptez MediaWiki dans votre langue]<br /> * [https://www.mediawiki.org/wiki/Special:MyLanguage/Manual:Combating_spam Apprendre comment lutter contre le pourriel dans votre wiki]</div>

Guillaume
Warning: Cannot modify header information - headers already sent by (output started at /home/lestanvi/wiki/includes/session/Session.php:48) in /home/lestanvi/wiki/includes/WebResponse.php on line 74