OpenLLM-France/wikimedia huggingface dataset:
# Aller plus loin avec GRUB/Des commandes derrière les menus

* Utilisation basique
* Clavier QWERTY des États-Unis
* Des commandes derrière les menus
* Dynamique des commandes
* Des commandes de l'exemple
* Des variables d'environnement
* Des systèmes de fichiers
* Utilisation basique
* Clavier QWERTY des États-Unis
* Des commandes derrière les menus
* Dynamique des commandes
* Des commandes de l'exemple
* Des variables d'environnement
* Des systèmes de fichiers
[ Modifier le sommaire ]
GRUB nous apparait sous la forme d'une menu. S'il est possible de déplacer dans le menu la sélection du système d'exploitation et de le lancer, GRUB offre d'autres possibilités.

## éditeur du mode "e"

Une fois une entrée de menu surlignée, il est possible d'en voir la logique. La touche e permet de passer dans le mode "e". Ce mode "e" permet de voir les commandes derrière cette entrée de menu. Dans un premier temps, les commandes qui s'affichent sont les commandes qui sont exécutées pour charger le système d'exploitation mentionné.
En réalité, GRUB offre d'autres possibilités que de lire ces commandes:
* Il est possible d'exécuter ces commandes avec la touche F10
* Le logiciel utilisé étant un éditeur de texte, il est possible de retoucher les commandes avant de les lancer, mais nous reviendrons plus tard sur ce point.
Il est également possible de sortir de ce mode "e" avec la touche ESC et d'accéder à la ligne de commande avec la touche c.

## ligne de commande du mode "c"

La touche c permet de passer dans le mode "c". Ce mode "c" permet de lancer des commandes et d'en voir les résultats, sur un écran défilant en mode texte, selon le principe d'une ligne de commande.
Par exemple, la commande "help" permet d'afficher les commandes disponibles. Une autre commande permet de revenir au mode initial.

## Exemple d'une séquence de lancement

Nous présentons ici la structure d'une commande de lancement au travers d'un exemple.
A titre d'illustration sont reproduites ci-dessous un exemple de commandes qui peuvent éventuellement être présente dans une entrée du menu GRUB. Le commandes sont expliquées après le commentaire introduit par le caractère dièse (#). Cela ne signifie pas pour autant que ce caractère est reconnue par GRUB.
Nous voyons deux traitements conditionnels:
L'instruction if condition then action ; fi permet d'exprimer une exécution conditionnelle à l'image de ce que peut faire le langage bash La condition est l'instruction shell présente entre le if et le then. L'action est l'action réalisée lorsque la condition est vraie.
La condition, compare la variable $grub_platform à la valeur xen ... Le x de gauche est une astuce permettant d'éviter le cas de la chaîne vide. Ici, l'action est une séquence de commandes séparées par le caracatère ';' L'action consiste dans le chargement de deux modules: xzio et lzopio.
# Économie

Cette page vise à classer les livrels entre l'économie réelle et l'économie financière.
- Économie réelle
- Économie financière
# Économie/Économie réelle

Cette page vise à répertorier les livrels sur l'économie réelle. L'économie réelle est l'inverse de l'économie financière puisqu'elle vise à favoriser les industries, pas la finance.
- L'économie pour les enfants
- L'économie pour les petits
- Morale Économique des Métiers
# Économie réelle

Cette page vise à répertorier les livrels sur l'économie réelle. L'économie réelle est l'inverse de l'économie financière puisqu'elle vise à favoriser les industries, pas la finance.
- L'économie pour les enfants
- L'économie pour les petits
- Morale Économique des Métiers
# Mathc complexes/a18

Propriétés et Applications
L'étude de ce chapitre peut ce faire à l'aide de cette Playlist..
# Mathc complexes/Sommaire

Introduction
Quelques sujets abordés : (voir la Playlist)
Matrices pour les Transformations de Fourier Discrètes.
Déterminant. Produit en croix. L'Inverse par le Déterminant.
Résoudre un Système d'Équations. Variables Libres. Les Bases. Projections sur un Sous-Espace Vectoriel.
Produit Scalaire. La QR décomposition. Les Vecteurs propres dans C. Les Vecteurs propres dans R. Fonctions matricielles. Décomposition polaire. Décomposition par les Vecteurs X . Pseudo Inverse Gauche. Pseudo Inverse Droit. Trois algorithmes pour le pseudo inverse gauche.
# Mathc complexes/a169

Application

## Travailler dans R : Fonctions matricielles ex : cos(A)

Dans cette section, je travaille sur des matrices symétriques avec des coefficients réelles avec les fonctions complexes.
Propriétés des valeurs propres et des vecteurs propres :
| EValue = cV_T * A * V | A : V * EValue * cV_T | invA = V * inv(EValue) * cV_T |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
Travailler sur les puissances :
| Sqrt(A) = V sqrt(EValue) T_V | A**1/3 = V EValue**1/3 T_V | A**3 == V EValue**3 T_V | A**4 = V EValue**4 T_V |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
Formules Trigonométriques :
| cos(A)**2 + sin(A)**2 = 1 | cos(2*A) = 2*cos(A)**2-1 | sin(2*A) == 2*sin(A)*cos(A) |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
# Mathc complexes/Fichiers h : vc m

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
La fonction c_mZ; permet de copier la matrice A dans la matrice B. Elle ne vérifie pas la taille des matrices. Le fait d'avoir conservé cette possibilité m'a rendu de grand service.
# Économie/Économie financière

L'économie financière vise à favoriser la finance.
- Introduction au cours de questions monétaires et financières
# Mathc complexes/h08a

Sommaire
# Mathc matrices/c21r

Sommaire
# Mathc complexes/a29

Sommaire

## La bibliothèque

La première vidéo du livre Matrice (Valeurs Réelles) peut être utile pour ce chapitre.
# Enseignement du kinyarwanda – Démonstratif

* Introduction
* Euphonie et collisions
* Substantifs
* Adjectif qualificatif
* Nombres
* Démonstratif
* Possessif
* Pronom personnel
* Verbes
* Conversation

## Adjectif démonstratif

Il existe deux adjectifs démonstratifs, selon l'éloignement:
* aha : proximité
* hariya : éloignement
| singulier | singulier | singulier | pluriel | pluriel | pluriel |
| classe | proximité | éloignement | classe | proximité | éloignement |
| umu- | uyu | uriya | aba- | aba | bariya |
| umu- | uyu | uriya | imi- | iyi | iriya |
| in- | iyi | iriya | in- | izi | ziriya |
| i- | iri | liriya | ama- | aya | ariya |
| aka- | aka (aga) | kariya | utu- | utu | turiya |
| igi- | iki (igi) | kiryia | ibi- | ibi | biriya |
| uru- | uru | luriya | in- | izi | ziryia |
| ubu- | ubu | buriya | Ø | Ø | Ø |
L'adjectif démonstratif se place toujours avant le nom. La voyelle initiale du nom qui le suit est élidée.
Exemples:
* uyu muntu, uriya muntu : cet homme-ci, cet homme-là
* iyi misosi, iriya misosi : ces collines-ci, ces collines-là
* iyi nka, izi nka : cette vache, ces vaches
* uru rugo, luriya rugo : cet enclos-ci, cet enclos-là

## Pronom démonstratif

L'adjectif démonstratif employé seul forme le pronom démonstratif.
Exemples:
* uyu muntu, uyu : cette homme-ci, celui-ci
* iriya nka, iriya : cette vache-là, celle-là.
# Enseignement du kinyarwanda – Possessif

* Introduction
* Euphonie et collisions
* Substantifs
* Adjectif qualificatif
* Nombres
* Démonstratif
* Possessif
* Pronom personnel
* Verbes
* Conversation

## Déterminant possessif

Modèle : la porte de la maison.
Le déterminant possessif s'accorde en classe et en nombre avec le nom de l’objet possédé.
| Classe du possédé | umu- / aba- | umu- / imi- | in- / in- | i- / ama- | aka- / utu- | iki- / ibi- | uru- / in- | ubu- |
| Adjectif possessif | wa / ba | wa / ya | ya / za | rya / ya | ka / twa | kya / bya | rwa / za | bwa |
Lorsque le nom suivant l'adjectif commence par une voyelle (ce qui est très souvent le cas), le a final de l'adjectif possessif est élidé.
Exemples :
* umuryango w' inzu : la porte de la maison
* injangwe ry' umwana : le chat de l'enfant (injangwe y’ umwana : les chats de l'enfant)
* ibiti by' ishyamba : les arbres de la forêt
* ubumwe bw' igihugu : l'unité du pays

## Adjectif possessif

Modèle : ma maison, mon pays.
L'adjectif possessif se forme sur la base du pronom personnel du possedé auquel vient s'ajouter le pronom possessif du possesseur. Comme chacun des pronoms s'accorde en nombre et en classe, cela donne 15 x 15, soit 255 combinaisons différentes. L'adjectif possessif se place toujours après le nom du possédé.
| Possédé | Possesseur | Possesseur | Possesseur | Possesseur | Possesseur | Possesseur |
| Possédé | moi | toi | lui / elle | nous | vous | eux / elles |
| umu- | wanjye | wawe | we | wacu | wanyu | wabo |
| aba- | banjye | bawe | be | bacu | banyu | babo |
| imi- | yanjye | yawe | ye | yacu | yanyu | yabo |
| in- | yanjye | yawe | ye | yacu | yanyu | yabo |
| in- | zanjye | zawe | ze | zacu | zanyu | zabo |
| i- | ryanjye | ryawe | rye | ryacu | ryanyu | ryabo |
| ama- | yanjye | yawe | ye | yacu | yanyu | yabo |
| aka- | kanjye | kawe | ke | kacu | kanyu | kabo |
| utu- | twanye | twawe | twe | twacu | twanyu | twabo |
| iki- | cyanjye | cyawe | cye | cyacu | cyanyu | cyabo |
| ibi- | byanjye | byawe | bye | byacu | byanyu | byabo |
| uru- | rwanjye | rwawe | rwe | rwacu | rwanyu | rwabo |
| in- | zanjye | zawe | ze | zacu | zanyu | zabo |
| ubu- | bwanjye | bwawe | bwe | bwacu | bwanyu | bwabo |
Exemples :
* imbwa yanjye : mon chien; imbwa zanjye : mes chiens; imbwa yawe : ton chien.
* urugo rwe : son domaine.
* igihugu cyabo : leur pays.

## Pronom possessif

Modèle : le mien, le tien, le sien, etc.
Le pronom possessif se forme à partir de l'adjectif possessif du possesseur, précédé de la voyelle initiale du préfixe du possédé.
Exemples :
* umurizo w' imbwa -> umurizo wayo -> uwayo : la queue du chien -> sa queue -> la sienne.
* igihugu cy' umwana -> igihugu cye -> icye : le pays de l'enfant -> son pays -> le sien.
# Mathc matrices/05u

Application
| GJ_PP_FreeV_mR; | GJ_PP_FreeV_Value0_mR; |
| /* -------------------------------- */ /* -------------------------------- */ double **GJ_PP_FreeV_mR( double **Ab, double **b_free ) { double **new_Ab; int rsize_Ab = rsize_R(Ab); int r; new_Ab = i_Abr_Ac_bc_mR(csize_A_R(Ab), csize_A_R(Ab), C2); c_nr_mR(Ab,rsize_Ab,new_Ab); zero4_under_all_pivot_mR(new_Ab); put_freeV_TP_mR(new_Ab,rsize_Ab); r=Ab[C_SIZE_A][C0]-C1; while( r>R1 ) zero_below_pivot_gj1Ab_mR(new_Ab,r--); sort_c_mR(new_Ab); sort_r_mR(new_Ab); c_Ab_b_mR(new_Ab,b_free); f_mR(new_Ab); return(b_free); } /* -------------------------------- */ /* -------------------------------- */ | /* ------------------------------------ */ /* ------------------------------------ */ void GJ_PP_FreeV_Value0_mR( double **Ab, double **b_free ) { double **new_Ab; /* int r_not_0 = rsize_R(Ab) - ((csize_R(Ab) - csize_A_R(Ab)-C1) -C1); */ int r_not_0 = 2*rsize_R(Ab) - csize_R(Ab) + C2; int r; new_Ab = i_Abr_Ac_bc_mR(rsize_R(Ab), csize_A_R(Ab), csize_R(Ab)-rsize_R(Ab)); c_mR(Ab,new_Ab); zero4_under_all_pivot_mR(new_Ab); put_freeV_TP_mR(new_Ab,r_not_0); r=Ab[C_SIZE_A][C0]-C1; while( r>R1 ) zero_below_pivot_gj1Ab_mR(new_Ab,r--); sort_c_mR(new_Ab); sort_r_mR(new_Ab); c_Ab_b_mR(new_Ab,b_free); f_mR(new_Ab); return(b_free); } /* ------------------------------------ */ /* ------------------------------------ */ |
put_freeV_TP_mR;
# Mathc matrices/05s

Application
| svd_V_Cn_mR; | svd_U_Cn_mR; |
| /* -------------------------------- */ /* -------------------------------- */ double **svd_V_Cn_mR( double **A, double **V ) { int i; int j; int r = rsize_R(A); int c = csize_R(A); double **tA = i_mR(c,r); double **tAA = i_mR(c,c); double **AtA = i_mR(r,r); double **EValue = i_mR(c,C1); double **EV = i_mR(c,c); double **Ab; double **Ab0; double **b = i_mR(c,C1); double **Ide = i_mR(c,c); double **sIde = i_mR(c,c); double **tAAsIde = i_mR(c,c); transpose_mR(A,tA) ; mul_mR(A,tA,AtA); eigs_mR(AtA,EValue); mul_mR(tA,A,tAA); eye_mR(Ide); for(i=R1; i<= rsize_R(EValue); i++) { if(EValue[i][C1]) { smul_mR(EValue[i][C1],Ide,sIde); sub_mR(tAA,sIde,tAAsIde); Ab = c_A_b_Ab_mR(tAAsIde,b, i_Abr_Ac_bc_mR(c,c,C1)); GJ_PP_FreeV_mR(Ab,EV); c_c_mR(EV,C2,V,i); } else { /* smul_mR(EValue[i][C1]==0,Ide,sIde); sub_mR(tAA,sIde,tAAsIde); */ Ab0 = c_A_b_Ab_mR(tAA,b, i_Abr_Ac_bc_mR(c,c,(C1+c-r))); GJ_PP_FreeV_Value0_mR(Ab0,EV); for(j=C2; i<=rsize_R(EValue); i++,j++) c_c_mR(EV,j,V,i); } } Normalize_mR(V); f_mR(EValue); f_mR(EV); f_mR(tA); f_mR(tAA); f_mR(AtA); f_mR(Ab); f_mR(Ab0); f_mR(b); f_mR(Ide); f_mR(sIde); f_mR(tAAsIde); return(V); } /* -------------------------------- */ /* -------------------------------- */ | /* -------------------------------- */ /* -------------------------------- */ double **svd_U_Cn_mR( double **A, double **U ) { int i; int r = rsize_R(A); int c = csize_R(A); double **tA = i_mR(c,r); double **AtA = i_mR(r,r); double **EValue = i_mR(r,C1); double **EV = i_mR(r,r); double **Ab; double **b = i_mR(r,C1); double **Ide = i_mR(r,r); double **sIde = i_mR(r,r); double **AtAsIde = i_mR(r,r); transpose_mR(A,tA) ; mul_mR(A,tA,AtA); eigs_mR(AtA,EValue); eye_mR(Ide); for(i=R1; i<=rsize_R(EValue); i++) { smul_mR(EValue[i][C1],Ide,sIde); sub_mR(AtA,sIde,AtAsIde); Ab = c_A_b_Ab_mR(AtAsIde,b, i_Abr_Ac_bc_mR(r,r,C1)); GJ_PP_FreeV_mR(Ab,EV); c_c_mR(EV,C2,U,i); } Normalize_mR(U); f_mR(EValue); f_mR(EV); f_mR(tA); f_mR(AtA); f_mR(Ab); f_mR(b); f_mR(Ide); f_mR(sIde); f_mR(AtAsIde); return(U); } /* -------------------------------- */ /* -------------------------------- */ |
# Mathc complexes/04d

Application

## Étude du code :

(voir dans la fin de la Playlist les vidéos (1..6) intitulés Big Problems)
Matrices réelles non symétriques. (vidéo 2) :
* Étude sur la partie réelle des valeurs propres.
* Valeurs aléatoires
Étude sur la partie imaginaire des valeurs propres. (vidéo 3) :
| Rappel | Les valeurs complexes | Calculer les valeurs imaginaires |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
Créer des nouveaux exemples. (vidéo 4) :
| Créer un nouvel exemple. | Le tester |
| Valeurs aléatoires | Entrez vos données |
* Attention une nouvelle fonction 31/12/2024 : c_U_D_mZ(EValue,D); (copier un vecteur dans une matrice diagonale)
Calculer les valeurs propres et les vecteurs propres d'une matrice [2x2]. :
| Créer un nouvel exemple. | Calculer les valeurs propres | * Calculer les vecteurs propres | Vérifions les calculs précédents |
| Valeurs aléatoires | Entrez vos données | Entrez vos données | Entrez vos données |
Calculer les valeurs propres et les vecteurs propres d'une matrice [3x3]. (vidéo 5) :
| Créer un nouvel exemple. | Calculer les valeurs propres | * Calculer les vecteurs propres | Vérifions les calculs précédents |
| Valeurs aléatoires | Entrez vos données | Entrez vos données | Entrez vos données |
Calculer les valeurs propres et les vecteurs propres d'une matrice [4x4]. (vidéo 6) :
| Créer un nouvel exemple. | Calculer les valeurs propres | * Calculer les vecteurs propres | Vérifions les calculs précédents |
| Valeurs aléatoires | Entrez vos données | Entrez vos données | Entrez vos données |
# Mathc matrices/Sommaire

Quelques sujets abordés :
Déterminant. Produit en croix. Gauss-Jordan : Total Pivoting. Analyse d'un réseau. Analyse d'un circuit électrique . Gauss-Jordan : Partial Pivoting. Équilibrer une équation chimique. Trouver une base pour ....
Produit scalaire. La QR décomposition. Le Pseudo inverse (SVD). Méthode des moindres carrés . La décomposition par les vecteurs propres . Valeurs propres complexes .
# Programmation D/Conclusion

* Avant de commencer
* Votre premier programme
* Éléments de base du langage et programmation impérative
* Programmation orientée objet
* Éléments avancés du langage
* Outils
* Annexes
* Conclusion
* Avant de commencer
* Votre premier programme
* Éléments de base du langage et programmation impérative
* Programmation orientée objet
* Éléments avancés du langage
* Outils
* Annexes
* Conclusion
[ Modifier le sommaire ]

## À voir aussi

* Le site officiel sur le langage D,
* La documentation de l'API tango,
* exemple et tutoriel autour de la bibliothèque tango,
* Le site tango,
* Les ressources de digital mars,
* Les spécifications du langage D (version d1),
* « Débuter avec le langage D »,
* blog parlant de l'actualité du langage D,
* Les wikibooks consacrés au D,
* (en) Kris Bell, Lars Ivar Igesund, Sean Kelly et Michael Parker, Learn to Tango with D, Apress, février 2008 (ISBN 978-1-59059-960-0, lire en ligne),
* Sur freenode : #d, #d.tango et #ldc.

## Crédits

Ce wikilivre est la reprise d'un article consacré à D écrit par Bioinfornatics et publié dans le magazine muffin n°3 (octobre 2010).
L'auteur tient également à créditer :
* misc pour lui avoir fait découvrir gobby et avoir aidé à la relecture,
* trashy pour sa participation à la relecture,
* paulk pour ses remarques avisées et sa contribution à la relecture,
* djezael pour son sens de l'orthographe et ses tournures de phrases,
* Eyyub pour avoir tester tous les exemples et avoir comblé certains points noirs.
# Programmation/Sommaire

* Historique
* Abstraction

## Concepts de base

* Commentaires
* Instructions
* Variables
* Types
* Expressions
* Comparaisons
* Instructions de contrôle
* Entrées-sorties

## Concepts spécifiques

* Manipulation de chaînes
* Procédures et fonctions
* Gestion de mémoire
* Gestion des exceptions
* Paradigmes de programmation
* Programmation séquentielle
* Programmation concurrente
* Programmation impérative
* Programmation orientée objet
* Programmation générique
* Programmation orientée aspect
* Programmation fonctionnelle
* Programmation logique
* Programmation par contrat

## Logiciels

* Eclipse
* NetBeans
* PhpStorm
* PyCharm
* SciTE
* Visual Studio Code

## Annexes

* Structure et style
* Règles de programmation
* Langages
* Bonjour le monde
# PyQt/Premier exemple : Hello World !

Comme tout bon guide de programmation qui se respecte, nous allons commencer par vous montrer un exemple d'implémentation d'un Hello World. Ce programme affiche une fenêtre contenant un bouton avec le texte Hello World !. Si vous cliquez sur le bouton, la fenêtre se ferme et le programme se termine.
ou plus court :
La légende détaillée est disponible dans les pages suivantes.
# Framework Spring/Hello world!

* Présentation de Spring
* Mise en place de l'environnement
* Création d'un projet simple
* Hello world!
* Application Context
* Fichier properties
* Bases de données
* Resources
* Configuration par annotations
* Log4j
* Les beans
* Présentation de Spring
* Mise en place de l'environnement
* Création d'un projet simple
* Hello world!
* Application Context
* Fichier properties
* Bases de données
* Resources
* Configuration par annotations
* Log4j
* Les beans
[ Modifier le sommaire ]

# Hello world! avec Java

Pour afficher dans la console "Hello world!", il suffit de modifier la méthode main de la manière suivante :
Cela donne le résultat suivant dans la console :
Ceci constitue un des programmes java les plus simples et ne fait pas appel à Maven ou Spring.

# Hello world! avec Spring

L'une des fonctionnalités de Spring est de permettre l'injection de données dans des instances de classes et cela en dehors de cette classe. On peut ainsi créer une classe qui sera paramétrée par un fichier de configuration externe. Cette paramétrisation s'effectue via un bean, c'est-à-dire un conteneur que l'on met autour de la classe pour insérer des données. Il ne s'agit pas ici d'accéder à la classe qui s'effectue toujours de manière classique.
On peut créer un fichier Beans.xml qui va définir l'ensemble des beans, on le place à la racine du dossier source. On peut créer la classe en question ici MessageDisplayer dans le package principal :

## Classe paramétrée

La classe MessageDisplayer peut être définie comme un simple afficheur :
C'est la chaine message que Spring va permettre d'initialiser depuis l'extérieur.

## Fichier de beans

Dans ce fichier on définit un bean lié à la classe MessageDisplayer.
On indique au départ qu'il s'agit d'un fichier xml avec le numéro de la norme ainsi que le type d'encodage, ici UTF-8 qui est le plus universel dans les années 2010. On définit ensuite une balise beans contenant l'ensemble des beans. L'espace de nom est défini par xmlns et permet d'avoir une référence pour les éléments du xml, il va de paire avec l’instance de schéma définie par xmlns:xsi. On donne ensuite les localisations en elles-mêmes du namespace et du xsd, XML Schema Definition, à utiliser, c'est ce dernier qui est le plus explicite.
Ensuite on arrive à la partie propre au projet c'est-à-dire l'ensemble des beans. On crée un bean avec comme classe celle qui nous intéresse ici. On peut spécifier de multiples autres paramètres notamment le nom via name. La chaîne message définie dans la classe MessageDisplayer reçoit un contenu "Hello world!" qui sera initialisé à la création de l'objet.

## Lien entre configuration et bean

Il faut modifier la classe principale pour faire une utilisation de MessageDisplayer :
On récupère tout d'abord le contexte d'application paramétrée avec le fichier de bean. On crée ensuite un MessageDisplayer initialisé avec les paramètres du bean, puis on appelle la fonction d'affichage. À la fin on ferme le contexte.

## Résultat

La sortie sur la console est la suivante :
On peut voir ici qu'on a des logs de Spring qui sont apparues.
# ZK/Hello World

Créer un répertoire dans /tomcat/webapps/zkdemo/.
Crée un fichier hello.zul dans ce répertoire (ici : mestests) à l'aide d'un éditeur de texte avec le contenu suivant :
Le resultat, un magnifique Hello World dans une boite à demi bleu, devrait apparaitre à cette adresse http://localhost:8080/zkdemo/mestests/hello.zul (ou mestests est votre répertoire défini plus haut).