OpenLLM-France/wikimedia huggingface dataset:
# Programmation C sharp/Interfaces graphiques

Les applications de la plateforme .Net construisent leur interface graphique à partir de forms.

## Espaces de nom

Les deux principaux espaces de nom de l'interface graphique sont :

### System.Windows.Forms

    Cet espace de nom contient les classes correspondant aux divers composants de l'interface graphique (fenêtre, bouton, label, ...).

### System.Drawing

    Cet espace de nom gère le dessin dans un composant (ligne, rectangle, texte, image, ...).

## Compilation

Si l'application possédant une interface graphique n'a pas besoin de console, il est possible de la supprimer en spécifiant winexe pour le paramètre target dans la ligne de commande du compilateur :
| Windows | csc /t:winexe fichier.cs |
| Linux (Mono) | gmsc -target:winexe fichier.cs |

## Une première fenêtre

La fenêtre est gérée par la classe Form de l'espace de nom System.Windows.Forms. En général, l'application dérive de cette classe pour ajouter des attributs de type composants, et gérer les évènements.
Cette première fenêtre comportera un label « Hello world ! » et un bouton « Fermer ».
Source :
Les propriétés des composants sont initialisées. Puis les composants sont ajoutés à la collection Controls des composants de la fenêtre.
La gestion de l’événement du clic sur le bouton se fait à l'aide de l'event Click.
Si la compilation se déroule bien, le lancement de l'application affiche la fenêtre suivante :
Cette fenêtre est redimensionnable, mais ne peut être plus petite que la taille minimale spécifiée dans le fichier source par la propriété MinimumSize.

## L'interface avec un éditeur graphique

Un éditeur graphique permet de créer facilement l'interface graphique grâce à une barre d'outils permettant d'ajouter des composants à la fenêtre de l'application, et de modifier leur propriétés.
Les ressources associées à l'interface graphique sont :
* les icônes, dont celle de l'application affichée dans le coin supérieur gauche de la fenêtre,
* les images,
* les curseurs de souris personnalisés,
* les chaînes de caractères (ressources en plusieurs langues).
Les éditeurs disponibles sont :
* Visual Studio et sa version Express gratuite, le plus diffusé
* SharpDevelop, un éditeur développé par une communauté de passionnés
* MonoDevelop, un éditeur développé par le projet Mono

## Les composants

Tous les composants ont pour classe de base System.Windows.Forms.Control. Cette classe définit les fonctionnalités communes à tous les composants.

## Les événements

La gestion des événements est assurée par l'utilisation d'events dont la méthode delegate correspondante a la signature suivante :
Le premier argument indique la source de l'évènement (le contrôle). Le deuxième argument donne des informations sur l'évènement (position de la souris, touche utilisée, ...).
# LispWorks CAPI/Créer une simple fenêtre/Propriétés génériques/Mnémoniques/Les mnémoniques sous Microsoft Windows

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Sous Microsoft Windows, l'utilisateur peut rendre les mnémoniques visible en appuyant et en maintenant la touche ALT enfoncée.
Windows XP peut caché les mnémoniques lorsque l'utilisateur n'utilise pas le clavier. Ceci est controllé en allant dans Panneau de configuration -> Affichage -> Apparance -> Effets -> Cacher les lettres soulignées ...
# LispWorks CAPI/Créer une simple fenêtre

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Jusqu'ici, vous n'avez vu que deux types d'éléments CAPI: l'interface (qui est le plus haut niveau élément CAPI, et est présente dans n'importe quelle fenêtre CAPI) et le bouton-poussoir. Cette section montre comment vous pouvez utiliser CAPI pour créer d'autres éléments d'interface graphique commun que vous êtes susceptibles d'avoir besoin.
Avant d'essayer les exemples dans ce chapitre, nous devrons définir les fonctions de test-callback et Bonjour dans le Listener. Le premier affiche d'abord la liste des arguments qui lui sont donnés, et retourne nil. La seconde affiche simplement un message.
Nous allons utiliser ces callback dans les exemples à venir.
* 4.1 Propriétés génériques
* 4.2 Spécification des titres
* 4.3 Affichage et saisie de texte
* 4.4 Zone de texte Stream
* 4.5 Divers éléments du bouton
* 4.6 Ajout d'une barre d'outils à une interface
# LispWorks CAPI/Liste des nouveautés

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Cette page permet de voir la date des mises à jour de ce livre. Souvent je dois travailler dans des sous sections et il est peu pratique de devoir fouiller pour savoir si une section a été mise à jour.
Il est à noter que cette page fut créée le 12 août 2010 donc il n'existe aucun historique avant ce jour. Merci de votre compréhension.

## À venir ...

Voici les pages qui seront bientôt ajoutées.
* 8.2 Regrouper les éléments du menu ensemble
* 8.4 Hiérarchie du menu CAPI

## Septembre 2010
### 10 septembre

* 5.6 Composantes du menu - Page créée et complétée

## Archives

* Août 2010
* 16 août
* 5.2 Panneaux de listes - Page créée et complétée
* 5.2.1 Liste d’interactions - Page créée et complétée
* 5.2.5 Filtres - Page créée et complétée
* 8.1 Création d'un menu - Page créée et complétée
* 8.3 Créer des éléments individuelles de menu - Page créée et complétée
* 8.5 Mnémoniques dans les menus - Page créée et complétée
* 8.7 Désactivation des éléments de menu - Page créée et complétée
* 13 août
* Créer une fenêtre simple est maintenant terminé
* 4.1.4 Mnémoniques - Page créée et complétée
* 4.1.4.1 Contrôler les mnémoniques - Page créée et complétée
* 4.1.4.2 Les mnémoniques sous Microsoft Windows - Page créée et complétée
* 4.5 Divers éléments du bouton - Page créée et complétée
* 4.5.1 Push Buttons - Page créée et complétée
* 4.5.2 Check Buttons - Page créée et complétée
* 4.5.3 Radio Buttons - Page créée et complétée
* 4.5.3 Mnémoniques dans les boutons - Page créée et complétée
* 12 août
* LispWorks CAPI‎ - Ajout d'un lien pour apprendre le Lisp
* Liste des nouveautés (page courante) - Page créée
* 4.2.2.1 Titre de fenêtre - Page créée et complétée
* 4.2.2.2 Titre pour des éléments - Page créée et complété
* 4.4.2 Stream interactif - Page créée et complétée
# LispWorks CAPI/Créer une simple fenêtre/Propriétés génériques

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Puisque les éléments du CAPI sont semblable à la classe CLOS, plusieurs éléments partagent des propriétés communes. Cette section décrit les propriétés que toutes les catégories décrites dans ce chapitre héritent.
* 4.1.1 Les barres de défilement
* 4.1.2 Couleurs d'arrière plant et de premier plan
* 4.1.3 Polices
* 4.1.4 Mnémoniques (seulement pour Windows et GTK+)
# LispWorks CAPI/Créer une simple fenêtre/Divers éléments du bouton/Mnémoniques dans les boutons

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
L'initarg :mnemonic permet de donner une lettre, chiffre ou symbole, l'attribut de mnémonique pour un boutton. (Pour un rappel, voir Mnémoniques)
Il existe aussi la possibilité de créé un mnémonique est spécifiant directement le caractère dans le nom. Il suffit d'utiliser l'initarg :mnemonic-text comme dans l'exemple qui suit.
Pour accéder à ce radio-button, appuyer sur les touches alt + m
# LispWorks CAPI/Créer une simple fenêtre/Propriétés génériques/Mnémoniques/Contrôler les mnémoniques

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Vous pouvez utiliser l'initarg :mnemonic pour controller des boutons individuels, des menus, des éléments du menu et des title pane. En voici un exemple :
L'initarg :mnemonic-title vous permet de spécifier le mnémonique d'un titre pour plusieurs type de classe de panneaux : list-panel, text-input-pane et option-pane. grid-layout support aussi :mnemonic-title lorsque :has-title-column-p est égale à vrai (t en lisp).

## Pour plus d'informantion voir

* Bouttons Mnémonique des bouttons
* Bouttons de groupés Mnémoniques dans les panneaux de boutons.
* Menus Mnémoniques dans les menus.
* et aussi le livre de référence CAPI de LispWorks
# LispWorks CAPI/Créer une simple fenêtre/Propriétés génériques/Mnémoniques

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Cette section s'applique seulement pour Windows et GTK+
Les mnémoniques sont les lettres soulignées dans des menus, titres, boutons. L'utilisateur peut utiliser un élément en utilisant la bonne combinaison de clé au clavier
* 4.1.4.1 Contrôler les mnémoniques
* 4.1.4.2 Les mnémoniques sous Microsoft Windows
# LispWorks CAPI/Créer une simple fenêtre/Zone de texte Stream/Stream interactif

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Un stream interactif est un bloc dans lequel est bâti un listener-pane
# LispWorks CAPI/Créer une simple fenêtre/Zone de texte Stream

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Il existe trois sous-classes du editor-pane qui peuvent être pris en charge par le stream de Common Lisp.
* 4.4.1 Le collectionneur
* 4.4.2 Stream interactif
* 4.4.3 Listener
# LispWorks CAPI/Fenêtre de choix/Panneaux de listes/Liste d’interaction

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Lorsque vous sélectionnez plusieurs éléments d'une liste, seulement le dernier élément restera souligné. La façon dont les éléments d'un list-panel interagissent sur la sélection peut être contrôlé avec le mot-clé :interaction.
La liste produit dans l'exemple précédente, est une liste à sélection simple car seulement un élément peut être séléctionné à la fois.
Il existe trois états pour la sélection d'élément dans un lisp-pane.
Comme mentionné dans la page précédente, il est possible d'obtenir une interaction particuliaire en utilisant le mot clé :interaction.
Notez que :no-selection n'est pas supporté dans par le lisp-panel. Pour afficher une liste d'éléments avec aucune sélection, vous devriez utiliser un display-pane
# LispWorks CAPI/Fenêtre de choix/Panneaux de listes

* LispWorks CAPI
* LispWorks CAPI
* Sommaire
* Accueil
* Liste de nouveautés
* Préface
* 1. Introduction au CAPI
* 2. Pour débuter
* 3. Considérations générales
* 4. Créer une fenêtre simple
* 5. Créer des fenêtres avec des choix
* 6. Aménagement des panneaux du CAPI
* 7. Modifier la fenêtre CAPI
* 8. Créer des menus
* 9. Définir une classe d'interface
* 10. Incitation à l'entrée
* 11. Créer sa propre fenêtre
* 12. Ports graphiques
* 13. Couleur du système
* 14. Imprimer à partir du CAPI
* Modifier ce modèle
Des listes d'éléments sélectionnables peuvent être créés à l'aide de la classe list-panel. En voici un exemple.
Notez la façon dont les éléments du list-panel sont convertis en symboles. La fonction print-function contrôle la façon dont les symboles sont affichés à l'écran.
Tout item de la liste peut être sélectionné en cliquant avec la souris.
Par defaut, le list-panel n'est qu'a sélection simple, ceci veut dire qu'on ne peut sélectionner qu'un élément à la fois. Cependant, pour changer ça, il ne suffit que d'utiliser le mot clé :interaction.
Vous pouvez aussi ajouter un callback pour les éléments en utilisant le mot clé :selection-callback
* 5.2.1 Liste d’interaction
* 5.2.2 Sélection étendue
* 5.2.3 Désélection, rétraction et actions
* 5.2.4 Sélections
* 5.2.5 Filtres
# Programmation ActionScript/Applications

* ActionScript
* Applications
* Sommaire
* Bases du langage
* Interactions
* Applications
* Api
* Liens
* Modifier ce modèle

## Quelques exemples en ActionScript 2

En ActionScript 2 le code est partout codé en procédural dans les actions de flash.
Il existe une exception lorsque l'on fait une classe externe comme ici :

## Quelques exemples en ActionScript 3

En ActionScript 3, le code objet est inclus dans des fichiers séparés .as. De plus, tout ce qui n'est pas dans les actions du timeline est orienté objet, c'est à dire que le corps du code doit être inclus dans un package et une classe.
Dans les actions, on peut coder en procédural comme en ActionScript 2.

### Exemple 1

Dans cet exemple on affiche un cercle sur la scène.

### Exemple 2

Dans cet exemple on réalise une messageBox.
# Cobol ANS 74

Le langage de programmation COBOL (COmmon Business Oriented Language) a été créé en 1959 par un comité de normalisation, la CODASYL (Conference On DAta SYstems Languages) qui avait pour mission de créer un langage standard pour la programmation des ordinateurs résolvant les problèmes commerciaux et administratifs. Le langage a connu plusieurs versions normalisées.
    avancé
* Une version imprimable du livre « Cobol ANS 74 » est disponible. (voir/ modifier)
Le Cobol est un langage de programmation créé en 1959.
Le langage COBOL (COmmon Business Oriented Language) a été créé par un comité de délégués de constructeurs et utilisateurs d'ordinateurs réunis à l'initiative du gouvernement américain. Ce comité de normalisation, la CODASYL (Conference On DAta SYstems Languages), s'est rassemblé pour la première fois en 1958. Il avait pour mission de définir un langage standard pour la programmation des ordinateurs en vue de résoudre les problèmes commerciaux et administratifs. En avril 1960, le comité publiait une première version du langage connu sous le nom de COBOL 60. Le langage fut ensuite revu, amélioré et complété en 61, 65 et 68. C'est en 1968 que fut défini l'USA Standard COBOL suite à une tentative de normalisation sous l'autorité de l'USASI (United States of America Standards Institute). De nouveau modifié en 1970, le COBOL USA porte maintenant le nom ANS COBOL spécifié par l'ANSI (American National Standards Institute). De nombreuses améliorations ont encore été apportées en 1974 et en 1985. Loin d'être un langage désuet et obsolète (il suffit de prendre connaissance de l'important nombre de grands comptes, publics ou privés, à maintenir à jour un ou plusieurs systèmes d'informations basés sur ce langage), le COBOL a fait l'objet d'une modernisation en 2002, implémentant la programmation orientée objet. Les normes ANS COBOL 1974 sont celles que nous étudierons dans ce livre.
* Spécifications initiales de COBOL de 1960
* CODASYL COBOL Journal of Development, 1968
* Révision proposée en 1974 de l'American National Standard COBOL

## Sommaire

* Généralités
* Environnement de développement
* Structure générale
* Bases du Cobol
* Divisions, sections paragraphes
* Fichiers
* Tables
* Liens
# Programmation/Gestion de mémoire

* 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
* 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
[ Modifier le sommaire ]
La mémoire d'un ordinateur est partagée entre tous les programmes qui s'exécutent sur la machine. Le lancement d'un programme se fait en le chargeant dans une zone mémoire allouée par le système d'exploitation, avant de lui passer la main en exécutant les instructions chargées dans la zone allouée.
Le programme peut ensuite allouer de la mémoire supplémentaire pour ses structures de données en utilisant les fonctions d'allocation dynamique de mémoire fournies par le système d'exploitation. La quantité totale de mémoire disponible est limitée : quand une zone n'est plus utilisée, le programme doit la libérer afin de la rendre disponible pour allouer une autre structure de données ou pour la rendre disponible à un autre programme.
Certains langages de programmation de haut niveau gèrent automatiquement l'allocation de mémoire (taille de zone à allouer calculée automatiquement), et la libération des zones qui ne sont plus référencées en utilisant le principe du ramasse-miette (une tâche de fond de libération automatique).
# Mathc complexes/04t

La décomposition par les vecteurs propres

## Calculer les vecteurs propres manuellement

Cette méthode sera utiliser pour calculer les vecteurs propres des valeurs propres multiples.
Étude sur les matrices 2x2
* Exemple de référence
* Calculer un vecteur propre
* Étudier les calculs intermédiaires
Étude sur les matrices 3x3
* Exemple de référence
* Calculer un vecteur propre
* Étudier les calculs intermédiaires
Étude sur les matrices 4x4
* Exemple de référence
* Calculer un vecteur propre
* Étudier les calculs intermédiaires

## Une valeur propre nulle

Étude sur les matrices 3x3
* Exemple de référence
* Calculer un vecteur propre
* Vérifions les calculs précédents
* Vérifier A v_λ = 0 quand λ = 0 (Rappel : A v_λ = λ v_λ)
Étude sur les matrices 4x4
* Exemple de référence
* Calculer un vecteur propre
* Vérifions les calculs précédents
* Vérifier A v_λ = 0 quand λ = 0 (Rappel : A v_λ = λ v_λ)
Étude sur les matrices 5x5
* Exemple de référence
* Calculer un vecteur propre
* Vérifions les calculs précédents
* Vérifier A v_λ = 0 quand λ = 0 (Rappel : A v_λ = λ v_λ)
Étude sur les matrices 6x6
* Exemple de référence
* Calculer un vecteur propre
* Vérifions les calculs précédents
* Vérifier A v_λ = 0 quand λ = 0 (Rappel : A v_λ = λ v_λ)
# Mathc complexes/a326

Produits scalaires

## Théorie : Vecteurs propres pour programmeurs.

. Toutes ces pages sont basés sur les deux fonctions ci-dessous qui donnent les vecteurs propres et les valeurs propres
. eigs_V_mZ(A, V, FACTOR_E);
. eigs_mZ(A, EValue);
# Mathc complexes/02b
## Valeurs propres multiples

Étude sur les matrices 3x3
* Vérifier les valeurs propres : ici deux valeurs propres identiques
* Calculer les vecteurs propres des deux valeurs propres identiques
* Sauver les vecteurs propres des deux valeurs propres identiques
* Calculer le dernier vecteur propre
* Sauver le dernier vecteurs propres, et vérifier les calculs
Étude sur les matrices 4x4
* Vérifier les valeurs propres : ici trois valeurs propres identiques
* Calculer les vecteurs propres des trois valeurs propres identiques
* Sauver les vecteurs propres des trois valeurs propres identiques
* Calculer le dernier vecteur propre
* Sauver le dernier vecteurs propres, et vérifier les calculs
Étude sur les matrices 6x6
* Vérifier les valeurs propres : ici deux et trois valeurs propres identiques
* Calculer les vecteurs propres des trois valeurs propres identiques
* Calculer les vecteurs propres des deux valeurs propres identiques
* Calculer le dernier vecteur propre
* Vérifier les calculs

## Valeurs propres multiples nulles

Étude sur les matrices 3x3
* Vérifier les valeurs propres : ici deux valeurs propres identiques nulles
* Calculer le premier vecteur propre
* Calculer les vecteurs propres des deux valeurs propres nulles
* Vérifier les calculs
* Vérifier A v_λ = 0 quand λ = 0 (Ici : λ2 et λ3)