OpenLLM-France/wikimedia huggingface dataset:
# Programmation JavaFX/Apparence 3D

* Base commune
** Introduction
** Composants d'une application JavaFX
* Interface graphique (2D)
** Classes 2D
* Scene 3D
** Formes 3D
** Apparence
** Interactions
* Media
** Jouer une vidéo ou un son
* Outils
** Scene Builder
* Base commune
** Introduction
** Composants d'une application JavaFX
* Interface graphique (2D)
** Classes 2D
* Scene 3D
** Formes 3D
** Apparence
** Interactions
* Media
** Jouer une vidéo ou un son
* Outils
** Scene Builder
[ Modifier le sommaire ]
L'apparence par défaut des objets de la scène construite au chapitre précédent est plutôt monotone :
Le but de ce chapitre est de montrer comment améliorer l'apparence des objets en leur donnant une couleur ou une texture.
L'apparence d'un objet (couleur, reflets, texture, ...) est défini par une instance de la classe abstraite Material. JavaFX fournit une classe concrète nommée PhongMaterial, nommée d'après le modèle d'ombrage de Phong.

## Couleur

Les méthodes de la classe PhongMaterial sont les suivantes :

### setDiffuseColor(Color)

    Définit la couleur principale.

### setSpecularColor(Color)

    Définit la couleur des reflets des sources lumineuses.

### setSpecularPower(float)

    Définit la puissance de réflexion.

### Exemple

On peut ensuite assigner l'apparence aux objets :

## Texture

Une texture est définie par une image pouvant définir la couleur de diffusion, de réflexion, d'illumination de l'objet.
Les méthodes de la classe PhongMaterial concernant les textures sont les suivantes :

### setDiffuseMap(Image)

    Définit la texture pour la couleur de diffusion.

### setSpecularMap(Image)

    Définit la texture pour la couleur de reflet.

### setSelfIlluminationMap(Image)

    Définit la texture pour l'intensité d'illumination.

### setBumpMap(Image)

    Définit la texture pour la granularité de l'objet.

### Exemple

L'exemple ci-dessous utilise l'image Red-brick-wall-texture-1.jpg disponible sur commons.

## Ajustements

La texture de la base carrée fait apparaître les deux triangles car les 2 faces adjacentes sont associées à deux triangles qui ne sont pas adjacent dans la texture :
En ajustant la texture comme dans le code ci-dessous, on obtient une texture uniforme pour la base carrée :
Dans cette version, la caméra est fixe. Le chapitre suivant résout le problème en ajoutant la possibilité d'interagir avec la souris pour déplacer la caméra.
# Astrologie/L'interprétation d'un thème astral/Astrologie statique/Sceau personnel

Le sceau personnel est une méthode astrologique mise au point par Arielle Aumont pour déterminer la dominante d'un thème astral. Un exemple sera donné à partir des thèmes de Charles d'Angleterre et Lady Di, illustrant le fait que, pour paraphraser Antoine de Saint-Exupery, ils ne regardaient pas « ensemble dans la même direction ».
# Mathc matrices/h09b

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc matrices/a12

Bibliothèque

## SVD : Matrices avec plus de lignes que de colonnes, ou matrices carrés

Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
* v_d.h ........................... Produit scalaire
** vdsvdrn.h ................... svd
** vdsvdf.h ..................... Appel de fonctions
Exemple pour tester la bibliothèque :
* clrscrn; stop; stop_w
# Mathc matrices/h12a

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc complexes/a60

Bibliothèque

## La décomposition par les vecteurs X

Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
* wd.h ........................ Déclaration des fichiers h
** wdx.h ........... Les fonctions pour la bibliothèque
J'ai essayer d'implémenter la fonction SVD (Décomposition en Valeurs Singulières). J'ai raté mon coups et je suis tombé sur cette décomposition.
Je l'ai appelé X pour me facilité la tache. Elle est basée sur deux vecteurs U, V et une matrice diagonal X.
* wdx.h
* X_V_mZ; Calculer le vecteur V.
* X_U_mZ; Calculer le vecteur U.
Exemple pour tester la bibliothèque :
* Exemple aléatoire
# Mathc complexes/a329

La décomposition par les vecteurs X

## X Value Decomposition .. Pseudo Inverse par la Gauche ... Pseudo Inverse par la Droite

. Toute ces pages sont basé sur les deux fonctions ci-dessous, qui donnent les vecteurs U et V.
Matrices avec plus de lignes que de colonnes. (Pseudo Inverse par la Gauche)
. X_V_mZ(A_T, V, FACTOR_E);
. X_U_mZ(A_T, U, FACTOR_E);
Ide = Pinv * A :
| X = U_T * A * V | A = U * X * V_T | Pinv = V * invX * U_T | Pinv : Valeurs extrêmes | Résoudre : Ax = B |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires | Coeff : +1.E+12 | Valeurs aléatoires |
| Entrez vos données | Entrez vos données | Entrez vos données | Coeff : +1.E-12 | Entrez vos données |
Matrices avec plus de colonnes que de lignes. (Pseudo Inverse par la Droite)
. X_V_mZ(A, V, FACTOR_E);
. X_U_mZ(A, U, FACTOR_E);
Ide = A * Pinv :
| X = V_T * A * U | A = V * X * U_T | Pinv = U * invX * V_T | Pinv : Valeurs extrêmes |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires | Coeff : +1.E+12 |
| Entrez vos données | Entrez vos données | Entrez vos données | Coeff : +1.E-12 |
Matrices carrées.
. X_V_mZ(A_T, V, FACTOR_E);
. X_U_mZ(A_T, U, FACTOR_E);
Déterminant non nul : ... ... ... (R == C) :
| Résoudre : Ax = B : | Résoudre : A x1 x2 ... xn = b1 b2 ... bn |
| Valeurs aléatoires | Valeurs aléatoires ... ... ... ... ... ... ... ... ... ... ... |
| Entrez vos données | Entrez vos données ... ... ... ... ... ... ... ... ... ... ... |
Fonctions matricielles trigonométriques :
| sin(2*A) = 2 cosA sinA | cos(2*A) = 2 cosA**2 - 1 | cos(2 A) = cos(A)**2 - sin(A)**2 |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
Fonctions matricielles trigonométriques hyperboliques :
| sinh(2*A) = 2 coshA sinhA | cosh(2*A) = 2 coshA**2 - 1 | cosh(2 A) = cosh(A)**2 + sinh(A)**2 |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
A = Q * P = (U * V_T) * (V * X * V_T) :
| A = Q * P = (U * V_T) * (V * X * V_T) ... R >= C | det(A) = det(Q) det(P) ... R == C |
| Valeurs aléatoire | Valeurs aléatoires |
# Mathc complexes/a328

La décomposition par les vecteurs X

## Décomposition d'une matrice en éléments propres (Matrices Symétriques Conjuguées)

. Dans cette partie X représente les valeurs propres et U représente les vecteurs propres. V n'est pas utilisé il est identique à U.
. X_U_mZ(A_T, U, FACTOR_E);
Opérations de bases :
| A = U * X * U_T | X = U_T * A * U | Inv = U * invX * U_T | Résoudre : Ax = B |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
Fonctions de matrices : :
| sqrt(A) = U sqrt(X) T_U | sqrt(A,1/3) = U sqrt(X,1/3) T_U |
| Valeurs aléatoires | Valeurs aléatoires |
Fonctions exponentielles et logarithmiques : :
| exp(A) = U exp(X) T_U | log(A) = U log(X) T_U |
| Valeurs aléatoires | Valeurs aléatoires |
Pour que les propriétés des exponentielles et des logarithme fonctionnent sur les matrices, if faut utiliser des matrices qui commutent.
Fonctions de matrices trigonométriques : :
| cos(A)**2 + sin(A)**2 = 1 | cos(2*A) = 2*cos(A)**2-1 | sin(2*x) = 2*sin(A)*cos(A) |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
Fonctions de matrices trigonométriques hyperboliques : :
| cosh(A)**2 - sinh(A)**2 = 1 | cosh(2*A) = 2*cosh(A)**2-1 | sinh(2*x) = 2*sinh(A)*cosh(A) |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
# Eurocode

Les Eurocodes sont les normes européennes (EN, Europäische Norm) de dimensionnement et de justification des structures de bâtiment et de génie civil. Les Eurocodes sont reconnus dans les 27 États membres de l'Union européenne et les pays membres de l'EFTA.

## Généralités

Les Eurocodes visent à remplacer les précédentes normes nationales afin d'aboutir à un ensemble de normes européennes.
En France, avant la parution des Eurocodes, ces bases étaient différentes en fonction des matériaux :
* Béton avec les règles BAEL 91 révisées 99,
* Bois avec les règles CB 71,
* Métal avec les règles CM 66 additif 80,
* Maçonnerie avec le DTU 20.1,
* Géotechnique avec les DTU 13.12, DTU 13.2 et fascicule 62 titre V.
L'objectif de ce document est d'apporter des éclaircissements ou une aide à la compréhension des normes Eurocodes. Il ne peut en aucun cas se substituer à la compétence d'un professionnel dans le cas où vous souhaitiez réaliser vous-même vos ouvrages.

## Conventions de rédaction

Afin d'alléger et de codifier la rédaction de ce livre, il convient de prendre en compte un certain nombre de conventions d'écriture.
* Certaines différences existent entre la norme européenne et la version française et sont notées dans les annexes nationales de chaque norme. Afin de déterminer si une valeur ou un commentaire d'une annexe nationale vient se supplanter à la norme européenne, il sera ajouté après la valeur ou au début du paragraphe $^{EU}$ pour la norme européenne et $^{FR}$ pour l'annexe nationale française.
* Pour que le lecteur puisse rapidement retrouver l'origine d'un paragraphe dans la norme afin, par exemple, de vérifier une information ou de lire le texte source, les références seront notées de la façon suivantes : E0, T2.1 signifiant Eurocode 0, Tableau 2.1. Pour un paragraphe, T est remplacé par P et pour une figure par F.
* Un abus de langage est couramment appliqué en remplaçant "les règles Eurocodes" par "les Eurocodes".
# Mathc matrices/e12a

SVD

## Matrices avec plus de lignes que de colonnes, ou matrices carrés (svd)

Toute ces pages sont basé sur les deux fonctions ci-dessous, qui donnent les vecteurs U et V.
SVD décomposition :
* Valeurs aléatoires
* Entrez vos données B[R4xC2]
Matrices n+R0 x n (matrices carrées):
* Matrice n+R0 x n
* S = U_T * B * V (valeurs singulières) (Erreur de signe)
* B = U * S * V_T
* P = V * invS_T * U_T (SVD : PseudoInverse)
* P = V * invS_T * U_T (PseudoInverse)
Matrices n+R2 x n :
* Matrice n+R2 x n
* S = U_T * B * V (valeurs singulières) (Erreur de signe)
* B = U * S * V_T
* P = V * invS_T * U_T (SVD : PseudoInverse)
* P = V * invS_T * U_T (PseudoInverse)

## Corrections manuelles des erreurs de signes

L'équation S = U_T * B * V donne des valeurs singulières négatives. Les valeurs singulières devraient toujours être positives. Je vous présente une méthode manuelle pour corriger ce problème.
Matrices carrées:
* Version aléatoire non corrigé, pour étudier le problème
* Matrice R3xC3
Matrices R > C:
* Version aléatoire non corrigé, pour étudier le problème
* Matrice R5xC2

## Étude de quelques propriétés

Calculons les U*UT et V*VT :
* Matrice R3xC3
* Matrice R5xC2
# Programmation Assembleur/x86/Conclusion

* Programmation Assembleur/x86
* Introduction
* Registres
* Les flags
* Copie entre registres et mémoire
* Les branchements
* La pile
* Les interruptions
* Opérations arithmétiques et logiques
* Interactions avec les périphériques
* Index
* Conclusion
* Modifier ce modèle
Le jeu d'instructions x86 est riche car il a évolué au fil des versions des processeurs, en particulier avec l'extension de l'ensemble des registres, passant de 16 bits à 32, puis à 64 bits. L'apprentissage de l'assembleur x86 peut être simplifié en apprenant les instructions par groupe : par taille de données manipulées, par sujet (voir les titres du sommaire).
Cependant, l'assembleur est un langage de bas niveau, manipulant directement le matériel, son usage est de nos jours moins fréquent. Il est utile pour développer des pilotes pour un système d'exploitation, créer des générateurs de code pour des langages de programmation compilés de plus haut niveau, ou développer des routines particulières nécessitant de hautes performances.
# Mathc matrices/26d

SVD

## Pseudo inverse une introduction

Les fonctions Pseudo-inverses gauche et droit.
Ide = Pinv_Rn_mR; * A (Plus de lignes que de colonnes.) :
* Valeurs aléatoires
* Valeurs aléatoires élevés (999999)
* Entrez vos données
Ide = A * Pinv_Cn_mR; (Plus de colonnes que de lignes.) :
* Valeurs aléatoires
* Valeurs aléatoires élevés (999999)
* Entrez vos données
Pseudo Inverse = inv(A_TA)*A_T
* Valeurs aléatoires
* Entrez vos données
# Mathc matrices/h12b

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Précis de grammaire viêtnamienne/Types de phrases

* Précis de grammaire viêtnamienne
* Sommaire
* Classes grammaticales
* Généralités
* Nom
* Pronom
* Adjectif
* Verbe
* Autres classes
* Propositions
* Types de phrases
* Modifier ce modèle

## Phases affirmatives

La phrase affirmative suit l'ordre sujet, verbe, objet (SVO).

## Phrases négatives

Pour former une phrase négative, on utilise une phrase affirmative à laquelle on ajoute la négation devant le verbe.
Il existe plusieurs formes de négations :
* không, négation générale, placée devant le verbe.
       Tôi không ăn dưa hấu.
       Je ne mange pas de pastèque.
* không phải, utilisée devant le verbe être (là).
       Tôi không phải là bác sĩ.
       Je ne suis pas médecin.

## Phrases interrogatives

Il existe plusieurs formes interrogatives,
Pour les questions demandant des réponses diverses, il y a des particules interrogatives, elles sont ajoutée à la fin de la phrase :
* ai, qui.
       Họ là ai?
       Qui sont-ils ?
* cái gì, que, quoi
       Bạn muốn cái gì?
       Que veux-tu ?
* ơ đâu, où. Cette particule utilise ơ (être dans le sens du lieu)
       tôi là ơ đâu?
       Où suis-je ?
Pour les questions dont les réponses sont de type oui ou nom :
* On peut ajouter phải không à la fin de la phrase affirmative.
       Bạn thích dưa hấu phải không?
       Est-ce que tu aimes la pastèque ?
* On peut ajouter có devant le verbe (có phải avant le verbe être) et không à la fin de la phrase.
       Cô ấy có thích không?
       Ést-ce qu'elle aime la pastèque ?
* 8/809
# Mathc matrices/h12c

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc matrices/05t

Application
| Pinv_Rn_mR; | Pinv_Cn_mR; |
| /* ------------------------------------ */ /* ------------------------------------ */ double **Pinv_Rn_mR( double **A, double **Pinv, double FACTOR ) { int r = rsize_R(A); int c = csize_R(A); double **FA = smul_mR(FACTOR,A, i_mR(r,c)); double **tFA = transpose_mR(FA, i_mR(c,r)); double **U = i_mR(r,c); double **tU = i_mR(c,r); double **V = i_mR(c,c); double **tUA = i_mR(c,c); double **EValue = i_mR(c,c); double **invEValue = i_mR(c,c); double **VinvEValue = i_mR(c,c); svd_U_Rn_mR(tFA,U); svd_V_Rn_mR(tFA,V); /* EValue = tU A V */ transpose_mR(U,tU); mul_mR(tU,A,tUA); mul_mR(tUA,V,EValue); inv_svd_mR(EValue,invEValue); /* PseudoInverse = V invEValue tU */ mul_mR(V,invEValue,VinvEValue); mul_mR(VinvEValue,tU,Pinv); f_mR(FA); f_mR(tFA); f_mR(U); f_mR(tU); f_mR(tUA); f_mR(V); f_mR(EValue); f_mR(invEValue); f_mR(VinvEValue); return(Pinv); } /* ------------------------------------ */ /* ------------------------------------ */ | /* ------------------------------------ */ /* ------------------------------------ */ double **Pinv_Cn_mR( double **A, double **Pinv, double FACTOR ) { int r = rsize_R(A); int c = csize_R(A); double **FA = smul_mR(FACTOR,A, i_mR(r,c)); double **U = i_mR(r,r); double **tU = i_mR(r,r); double **V = i_mR(c,c); double **tUA = i_mR(r,c); double **EValue = i_mR(r,c); double **tEValue = i_mR(c,r); double **invtEValue = i_mR(c,r); double **VinvtEValue = i_mR(c,r); svd_U_Cn_mR(FA,U); svd_V_Cn_mR(FA,V); /* EValue = tU A V */ transpose_mR(U,tU); mul_mR(tU,A,tUA); mul_mR(tUA,V,EValue); transpose_mR(EValue,tEValue); inv_svd_mR(tEValue,invtEValue); /* PseudoInverse = V invtEValue tU */ mul_mR(V,invtEValue,VinvtEValue); mul_mR(VinvtEValue,tU,Pinv); f_mR(FA); f_mR(U); f_mR(tU); f_mR(tUA); f_mR(V); f_mR(EValue); f_mR(tEValue); f_mR(invtEValue); f_mR(VinvtEValue); return(Pinv); } /* ------------------------------------ */ /* ------------------------------------ */ |
# Mathc complexes/a128

Application

## Série de Taylor

Travailler avec les exponentielles :
| ExpA | ExpA (2) | Exp_mZ; | ExpAplsB = ExpB * ExpA |
| Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires | Valeurs aléatoires |
Travailler avec les fonctions trigonométriques :
| ... I = coshA**2 - sinhA**2 ... | ... I = cosA**2 + sinA**2 ... |
| Valeurs aléatoires | Valeurs aléatoires |
# Mathc matrices/h12e

Application
| svd_V_Rn_mR; | svd_U_Rn_mR; |
| /* ------------------------------------ */ /* ------------------------------------ */ double **svd_V_Rn_mR( double **A, double **V ) { 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,V,i); } Normalize_mR(V); 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(V); } /* ------------------------------------ */ /* ------------------------------------ */ | /* ------------------------------------ */ /* ------------------------------------ */ double **svd_U_Rn_mR( double **A, double **U ) { int i; 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(r,C1); double **EV = i_mR(c,r); double **Ab; 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); eye_mR(Ide); mul_mR(tA,A,tAA); for(i=R1; i<=rsize_R(EValue); i++) { 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,U,i); } Normalize_mR(U); f_mR(EValue); f_mR(EV); f_mR(tA); f_mR(tAA); f_mR(AtA); f_mR(Ab); f_mR(b); f_mR(Ide); f_mR(sIde); f_mR(tAAsIde); return(U); } /* ------------------------------------ */ /* ------------------------------------ */ |
# Mathc complexes/Fichiers c : test02d

Application

## Matrice transposée conjugué, matrice transposée

Propriétés des matrices face à leurs transposées :
* Multiplier la matrice par sa conjuguée transposée
* Multiplier la matrice par sa transposée
* L'inverse d'une matrice face à sa conjuguée transposée
* L'inverse d'une matrice face à sa transposée
* La QR décomposition d'une matrice face à sa conjuguée transposée
* La QR décomposition d'une matrice face à sa transposée
# Mathc matrices/h11c

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc complexes/h05g

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc complexes/041

X Value Decomposition
| X_U_mZ(A, U, FACTOR_E); | X_V_mZ(A, V, FACTOR_E); |
| /* ------------------------------------ */ /* ------------------------------------ */ double **X_U_mZ( double **a, double **U, double FACTOR ) { int r = rsize_Z(a); int c = csize_Z(a); int i; double **A = smul_mZ(FACTOR,a, i_mZ(r,c)); double **ctA = ctranspose_mZ(A, i_mZ(c,r)); double **ActA = i_mZ(r,r); double **ctAA = i_mZ(c,c); double **X_Value = i_mZ(r,C1); double **Ide = eye_mZ(i_mZ(c,c)); double **zIde = i_mZ(c,c); double **ctAmnszIde = i_mZ(c,c); double **ctAb; double **b = i_mZ(c,C1 ); double **ctAb_free = i_Abr_Ac_bc_mZ( c,c,C2); double **b_free = i_mZ(c,C2); mul_mZ(A,ctA,ActA); eigs_mZ( ActA,X_Value); mul_mZ(ctA,A,ctAA); for(i = R1; i <= csize_Z(U); i++) { zmul_mZ(i_Z(X_Value[i][C1], X_Value[i][C2]),Ide,zIde); sub_mZ(ctAA,zIde,ctAmnszIde); ctAb = c_A_b_Ab_mZ(ctAmnszIde, b, i_Abr_Ac_bc_mZ(c,c,C1)); GJ_PP_FreeV_mZ(ctAb,ctAb_free,b_free); c_c_mZ(b_free,C2,U,i); } Normalize_mZ(U); f_mZ(A); f_mZ(ctA); f_mZ(ActA); f_mZ(ctAA); f_mZ(X_Value); f_mZ(Ide); f_mZ(zIde); f_mZ(ctAmnszIde); f_mZ(ctAb); f_mZ(b); f_mZ(ctAb_free); f_mZ(b_free); return(U); } /* ------------------------------------ */ /* ------------------------------------ */ | /* ------------------------------------ */ /* ------------------------------------ */ double **X_V_mZ( double **a, double **V, double FACTOR ) { int r = rsize_Z(a); int c = csize_Z(a); int i; double **A = smul_mZ(FACTOR,a, i_mZ(r,c)); double **ctA = ctranspose_mZ(A, i_mZ(c,r)); double **ActA = i_mZ(r,r); double **X_Value = i_mZ(r,C1); double **Ide = eye_mZ(i_mZ(r,r)); double **zIde = i_mZ(r,r); double **ctAmnszIde = i_mZ(r,r); double **ctAb ; double **b = i_mZ(r,C1); double **ctAb_free = i_Abr_Ac_bc_mZ( r,r,C2); double **b_free = i_mZ(r,C2); mul_mZ(A,ctA,ActA); eigs_mZ( ActA,X_Value); for(i = R1; i <= csize_Z(V); i++) { zmul_mZ(i_Z(X_Value[i][C1], X_Value[i][C2]),Ide,zIde); sub_mZ(ActA,zIde,ctAmnszIde); ctAb = c_A_b_Ab_mZ(ctAmnszIde, b, i_Abr_Ac_bc_mZ(r,r,C1)); GJ_PP_FreeV_mZ(ctAb,ctAb_free,b_free); c_c_mZ(b_free,C2,V,i); } Normalize_mZ(V); f_mZ(A); f_mZ(ctA); f_mZ(ActA); f_mZ(X_Value); f_mZ(Ide); f_mZ(zIde); f_mZ(ctAmnszIde); f_mZ(ctAb); f_mZ(b); f_mZ(ctAb_free); f_mZ(b_free); return(V); } /* ------------------------------------ */ /* ------------------------------------ */ |
# Mathc complexes/a61

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc complexes/a05

Bibliothèque

## QR, valeur propre, vecteur propre, valeur singulière

Copier la bibliothèque dans votre répertoire de travail avec les fichiers des parties précédentes :
* w_a.h ...................... Déclaration des fichiers h
* wd.h ........................ Déclaration des fichiers h
* wr.h ........................ Déclaration des fichiers h
** wddotu.h ........... Les fonctions pour la bibliothèque
** wdbm.h ..............
** wdeignv.h .......... eigs_V_mZ;
** wrm_sym.h ........ rcsymmetric_mZ(A,n);
** wrhm.h .............. r_hermitian_mZ(A,n);
Exemple pour tester la bibliothèque :
* La QR décomposition
# Mathc complexes/a62

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc complexes/a45

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc complexes/a44

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc matrices/h11b

Bibliothèque
Installer ce fichier dans votre répertoire de travail.
# Mathc matrices/e12b

SVD

## Matrices avec plus de colonnes que de lignes

Toute ces pages sont basé sur les deux fonctions ci-dessus, qui donnent les vecteurs U et V.
Les fonctions GJ_PP_FreeV_mR; et GJ_PP_FreeV_Value0_mR;
Nous pouvons observer que les dernières colonnes de V ne correspondent pas aux valeurs données par octave. Ces valeurs correspondent aux variables libres introduites lors de l'algorithme. Si il n'y à qu'une seul colonne de plus, le résultat est identique à celui d'octave. C'est à partir de deux colonnes de plus, qu'il diverge de octave. Cela ne semble pas affecter le calcul des matrices pseudo inverse.
SVD décomposition :
* Valeurs aléatoires
* Entrez vos données B[R3xC6]
Matrices m x m+C3 :
* U et V (les vecteurs singuliers)
* S = U_T * A * V (valeurs singulières) (Erreur de signe)
* A = U * S * V_T
* P = V * invS_T * U_T (SVD : PseudoInverse)
* P = V * invS_T * U_T (PseudoInverse)]

## Corrections manuelles des erreurs de signes

L'équation S = U_T * A * V donne des valeurs singulières négatives. Les valeurs singulières devraient toujours être positives. Je vous présente une méthode manuelle pour corriger ce problème.
Matrices R < C:
* Version aléatoire non corrigé pour étudier le problème.
* Matrice R3xC5

## Étude de quelques propriétés

Calculons les U*UT et V*VT :
* Matrice R3xC4
# Mathc matrices/h09d

Bibliothèque
Installer ce fichier dans votre répertoire de travail.