2020-04-23 11:25:03 +02:00
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Rotation d'orbitales"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"On peut écrire une matrice de rotation $R$ comme\n",
"$$\n",
"R = \\exp(X)\n",
"$$\n",
"où X est une matrice réelle anti-symétrique ($X_{ij} = -X_{ji}$) où $X_{ij}$ est la valeurs de l'angle de la rotation entre $i$ et $j$. Par exemple:\n",
"$$\n",
"R = \\left( \\begin{array}{cc}\n",
"\\cos \\theta & -\\sin \\theta \\\\\n",
"\\sin \\theta & \\cos \\theta \\end{array} \\right)\n",
"= \\exp\n",
" \\left( \\begin{array}{cc}\n",
" 0 & \\theta \\\\\n",
"- \\theta & 0 \\end{array} \\right)\n",
"$$\n",
"\n",
"D'abord on diagonalise $X^2$ :\n",
"$$\n",
"X^2 = W(-\\tau^2) W^\\dagger.\n",
"$$\n",
"Ensuite, $R$ peut être écrit comme\n",
"$$\n",
"R = W \\cos(\\tau) W^\\dagger + W \\tau^{-1} \\sin (\\tau) W^\\dagger X\n",
"$$"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## TODO\n",
"\n",
"Ecrire une fonction qui calcule $R$ a partir de $X$.\n",
"Tu vas avoir besoin de Lacaml:\n",
"* Intro a Lapack : https://lipn.univ-paris13.fr/~coti/doc/tutolapack.pdf\n",
"* Lapack user's guide : http://www.netlib.org/lapack/lug/\n",
"* Lacaml : https://mmottl.github.io/lacaml/\n",
"\n",
"Pour diagonaliser une matrice : syev\n",
"\n",
"Pour multiplier des matrices : gemm\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Localisation de Boys"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"$N$ orthonormal molecular orbitals\n",
"$$\n",
"\\phi_i({\\bf r})= \\sum_{k=1}^N c_{ik} \\chi_k\n",
"$$\n",
"$$\n",
"{\\cal B}_{2|4} = \\sum_{i=1}^N \\langle \\phi_i | ( {\\bf \\vec{r}} - \\langle \\phi_i| {\\bf \\vec{r}} | \\phi_i …\\rangle)^{2|4} | \\phi_i \\rangle\n",
"$$\n",
"$$\n",
"{\\cal B}_2= \\sum_{i=1}^N \\big[ \\langle x^2 \\rangle_i - \\langle x \\rangle^2_i + \\langle y^2 \\rangle_i - …\\langle y \\rangle^2_i + \\langle z^2 \\rangle_i - \\langle z \\rangle^2_i \\big]\n",
"$$\n",
"$$\n",
"{\\cal B}_2 = \\sum_{i=1}^N \\big[ \\langle x^4 \\rangle_i - 4 \\langle x^3 \\rangle_i \\langle x \\rangle_i\n",
" + 6 \\langle x^2 \\rangle_i \\langle x \\rangle^2_i\n",
"- 3 \\langle x \\rangle^4_i \\big] + \\big[ ...y...] + \\big[ ...z...] \n",
"$$\n",
"Minimization of ${\\cal B}$ with respect to an arbitrary rotation $R$\n",
"$$\n",
" \\langle R \\phi_i x^n R \\phi_i \\rangle = \\sum_{k,l=1}^N R_{ik} R_{il} \\langle \\phi_k| x^n | \\phi_l …\\rangle= \n",
"$$\n",
"$$\n",
"\\sum_{k,l=1}^N R_{ik} R_{il} \\sum_{m,o=1}^N c_{km} c_{ln} \\langle \\chi_m | x^n |\\chi_o \\rangle\n",
"$$\n",
"We need to compute\n",
"$$\n",
"S^x_{n;mo}= \\langle \\chi_m | x^n |\\chi_o \\rangle\n",
"$$\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Rotation de deux orbitales"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Rotation of angle $\\theta$\n",
"$$\n",
"\\tilde{\\phi}_1 = cos\\theta \\phi_1 -sin\\theta \\phi_2\n",
"$$\n",
"$$\n",
"\\tilde{\\phi}_2 = sin\\theta \\phi_1 +cos\\theta \\phi_2\n",
"$$\n",
"Let us note\n",
"$$\n",
"{\\cal B}_x(\\theta) = \\langle x^2 \\rangle_{\\tilde{1}} - \\langle x \\rangle^2_{\\tilde{1}} + \\langle x^2 \\rangle_{\\tilde{2}} - \\langle x \\rangle^2_{\\tilde{2}}\n",
"$$\n",
"and\n",
"\\begin{eqnarray}\n",
"A^x_{ij} & = & \\langle \\phi_i| x^2 | \\phi_j \\rangle \\\\\n",
"B^x_{ij} & = & \\langle \\phi_i| x | \\phi_j \\rangle \\;\\; i,j=1,2 \n",
"\\end{eqnarray}\n",
"We have\n",
"$$\n",
"{\\cal B}_x(\\theta) = A^x_{11}+A^x_{22} - ({\\tilde B}^{x2}_{11} + {\\tilde B}^{x2}_{22})\n",
"$$\n",
"with\n",
"$$\n",
"{\\tilde B}^{x2}_{11}= (cos^2\\theta B^x_{11} + sin^2\\theta B^x_{22} - sin2\\theta B^x_{12})^2\n",
"$$\n",
"$$\n",
"{\\tilde B}^{x2}_{22}= (sin^2\\theta B^x_{11} + cos^2\\theta B^x_{22} + sin2\\theta B^x_{12})^2\n",
"$$\n",
"$$\n",
"{\\cal B}(\\theta)= {\\cal B}_x(\\theta)+{\\cal B}_y(\\theta)+{\\cal B}_z(\\theta)=(x) + (y)+(z)\n",
"$$\n",
"with\n",
"$$\n",
"{\\cal B}_x(\\theta)= A^x_{11}+A^x_{22} \n",
"- [(cos^4\\theta+ sin^4\\theta)({B^x_{11}}^2+ {B^x_{22}}^2 )\n",
"$$\n",
"$$\n",
"+ 2 sin^2 2\\theta {B^x_{12}}^2\n",
"+ 2 sin 2\\theta cos 2\\theta (({B^x_{22}} -{B^x_{11}} ) {B^x_{12}}]\n",
"$$\n",
"and idem for $y$ and $z$. \n",
"Using the fact that\n",
"$$\n",
"cos^4\\theta+ sin^4\\theta= \\frac{1}{4} ( 3 + cos4\\theta)\n",
"$$\n",
"$$\n",
"{\\cal B}_x(\\theta)= A^x_{11}+A^x_{22} \n",
"- [ \\frac{1}{4} ( 3 + cos4\\theta)({B^x_{11}}^2+ {B^x_{22}}^2 )\n",
"$$\n",
"$$\n",
"+ (1 -cos 4\\theta) {B^x_{12}}^2\n",
"+ sin 4\\theta (({B^x_{22}} -{B^x_{11}} ) {B^x_{12}}]\n",
"$$\n",
"Finally, we get\n",
"\\begin{equation}\n",
"{\\cal B}(\\theta)= {\\cal B}(0) + \\frac{1}{4} [(1-cos4\\theta)\\beta+sin4\\theta \\gamma] \n",
"\\end{equation}\n",
"where\n",
"$$\n",
"{\\cal B}(0)= A^x_{11}+A^x_{22} -((B^{x}_{11})^2+(B^{x}_{22})^2) + [...y...] + [...z...]\n",
"$$\n",
"$$\n",
"\\beta= (B^x_{11}-B^x_{22})^2 - 4 {(B^x_{12})}^2 + [...y...] + [...z...]\n",
"$$\n",
"and\n",
"$$\n",
"\\gamma= 4 B^x_{12} (B^{x}_{11}-B^x_{22}) + [...y...] + [...z...]\n",
"$$\n",
"Let us compute the derivative; we get\n",
"$$\n",
"\\frac{\\partial {\\cal B}(\\theta)}{\\partial \\theta} = \n",
"\\beta sin4\\theta \n",
"+ \\gamma cos4\\theta\n",
"$$\n",
"Extrema of ${\\cal B}(\\theta)$\n",
"\\begin{equation}\n",
"tg4\\theta= -\\frac{\\gamma}{\\beta} \n",
"\\end{equation}\n",
"There are four extrema:\n",
"$$\n",
"4\\theta; \\;\\; 4\\theta +\\pi; \\;\\; 4\\theta+ 2\\pi; \\;\\; 4\\theta+ 3\\pi\n",
"$$\n",
"Value of the second derivative of $\\cal{B}$ at the extrema\n",
"Value of $\\cal{B}$ at the extrema\n",
"\\begin{equation}\n",
"\\frac{\\partial^2 B(\\theta)}{\\partial \\theta^2}= 4 cos4\\theta \\frac{\\beta^2 + \\gamma^2}{\\beta}\n",
"\\end{equation}\n",
"There are two minima and two maxima since $cos4\\theta= -cos4(\\theta+\\pi)= -cos4(\\theta+2\\pi)=-cos4(\\theta+3\\pi)$.\n",
"Value of $\\cal{B}$ at the extrema\n",
"\\begin{equation}\n",
"{\\cal B}(\\theta)= {\\cal B}(0) + \\frac{1}{4} (\\beta -\\frac{\\beta^2 + \\gamma^2}{\\beta} {cos4\\theta})\n",
"\\end{equation}\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
2020-04-24 00:04:21 +02:00
"source": [
2020-04-24 17:07:06 +02:00
"#use \"topfind\";;\n",
"#require \"jupyter.notebook\";;\n",
2020-04-24 00:04:21 +02:00
"#require \"lacaml.top\";;\n",
"#require \"alcotest\";;\n",
"#require \"str\";;\n",
"#require \"bigarray\";;\n",
"#require \"zarith\";;\n",
"#require \"getopt\";;\n",
"open Lacaml.D"
]
},
2020-04-27 08:17:19 +02:00
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Construction de la matrice de rotation R de taille n par n:\n",
"\n",
"On part de X ( n * n ) une matrice antisymétrique avec les éléments diagonaux nuls et où le terme X_ij correspond à la valeur de l'angle de rotation i et j (dans notre cas entre l'orbitale i et j).\n",
"\n",
"Tout d'abord on met au carré cette matrice X ( gemm X X ) tel que : \n",
" \n",
" X² = X . X\n",
" \n",
"Ensuite on la diagonalise la matrice X² ( syev X²). Après la diagonalidsation on obtient une matrice contenant les vecteurs propres ( W ) et un vecteur contenant les différentes valeurs propres. Ces valeurs propres correspondent aux valeurs propres de X² et sont négatives, pour obtenir celle correpondant à X et qui sont positives on doit appliquer la fonction valeur absolue au vecteur et ensuite prendre sa racine carré. On obtient donc un nouveau vecteur contenant les valeurs propres de X. Il faut ensuite transformer ce vecteur en une matrice diagonale, pour cela on construit une matrice (tau) n par n où les éléments extra diagonaux sont nulles et les éléments diagonaux prennent les différentes valeurs du vecteur, tel que l'élément 1 du vecteur devient l'élément {1,1} de la matrice.\n",
"\n",
"On peut ensuite écrire R comme :\n",
"\n",
" R = W cos(tau) W_t + W tau⁻¹ sin(tau) W_t X\n",
" "
]
},
2020-04-24 00:04:21 +02:00
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
2020-04-24 17:07:06 +02:00
"(*\n",
"Construction de la matrice de rotation R pour la rotation de n orbitales \n",
"*)\n",
2020-04-24 00:04:21 +02:00
"(*\n",
"NB: il faut que je change les noms des matrices car ce n'est pas toujours clair\n",
"*)\n",
"\n",
"(* Construction de la matrice X n par n *)\n",
2020-04-24 09:30:06 +02:00
"let n =5 \n",
2020-04-24 00:04:21 +02:00
"let ran=Mat.random ~range:1. ~from:0. n n;; (* Construction d'une matrice random n*n *)\n",
"\n",
2020-04-24 00:24:41 +02:00
"(* Antisymétrisation de la matrice *)\n",
2020-04-24 00:04:21 +02:00
"let antisym = Mat.init_cols n n (fun i j -> if i>j then -. ran.{i,j} else ran.{j,i});;\n",
"\n",
"(* 0 sur la diagonale -> X *)\n",
"let m = Mat.init_cols n n (fun i j -> if i=j then 0. else antisym.{i,j});; \n",
"\n",
"(* Fonction 2 en un *)\n",
"(*\n",
"let x = Mat.init_cols n n (fun i j -> if i=j then 0.\n",
" else if i>j then -. ran.{i,j} else ran.{j,i});;\n",
" *)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* Mise au carré de la matrice : X -> X² *)\n",
"let mm = gemm m m;;\n",
"\n",
2020-04-24 00:24:41 +02:00
"(* Copie de mm qui va être écrasée : X² *)\n",
2020-04-24 00:04:21 +02:00
"let copie_mm = lacpy mm;;\n",
"\n",
"(* Diagonalisation de X² *)\n",
"let diag = syev mm;;\n",
"\n",
"copie_mm;; (* Copie de la matrice avant diagonalisation *)\n",
"mm;; (* Matrice avec les eigenvectors -> W *)\n",
2020-04-24 00:24:41 +02:00
"diag;; (* Vecteur contenant les eigenvalues -> -tau² *)"
2020-04-24 00:04:21 +02:00
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* Passage de -tau² à tau² *)\n",
"let square_tau= Vec.abs diag;;\n",
"\n",
"(* Passage de tau² à tau *)\n",
"let tau = Vec.sqrt square_tau;;\n",
"\n",
"(* Passage du vecteur tau à la matrice avec les valeurs propres sur la diagonale *)\n",
"let m_tau = Mat.init_cols n n (fun i j -> if i=j then tau.{i} else 0.)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
2020-04-24 00:24:41 +02:00
"(* Calcul de cos tau à partir du vecteur tau *)\n",
"let cos_tau = Vec.cos tau;;\n",
2020-04-24 00:04:21 +02:00
"\n",
2020-04-24 00:24:41 +02:00
"(* Matrice cos tau *)\n",
"let m_cos_tau = Mat.init_cols n n (fun i j -> if i=j then cos_tau.{i} else 0.)\n",
"\n",
"(* Calcul de sin tau à partir du vecteur tau *)\n",
"let sin_tau = Vec.sin tau;; \n",
"\n",
"(* Matrice de sin tau *)\n",
"let m_sin_tau = Mat.init_cols n n (fun i j -> if i=j then sin_tau.{i} else 0.)\n",
2020-04-24 00:04:21 +02:00
"\n",
"(* Calcul de la transposée de W (mm) *)\n",
"let transpose_mm = Mat.transpose_copy mm;; \n",
2020-04-24 09:30:06 +02:00
"mm;;(* Vérification *) (* OK *)\n",
2020-04-24 00:04:21 +02:00
"\n",
2020-04-24 09:30:06 +02:00
"(* Calcul du vecteur tau^-1 *)\n",
"let tau_1 = Vec.init n (fun i -> 1. /. tau.{i}) ;;\n",
"tau;; (* Vétification *) (* OK *)\n",
"\n",
"(* Calcul de la matrice tau^⁻1 *)\n",
"let m_tau_1 = Mat.init_cols n n (fun i j -> if i=j then tau_1.{i} else 0.);;\n"
2020-04-24 00:04:21 +02:00
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* Calcul de R *)\n",
"(*\n",
2020-04-24 09:30:06 +02:00
"let r = gemm mm (gemm m_cos_tau transpose_mm) + gemm mm (gemm m_tau_1 ( gemm m_sin_tau (gemm transpose_mm m)))\n",
"*)"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* gemm mm (gemm m_cos_tau transpose_mm) -> W cos(tau) Wt *)\n",
"let a = gemm mm (gemm m_cos_tau transpose_mm);;\n",
"\n",
"(* gemm mm (gemm m_tau_1 ( gemm m_sin_tau (gemm transpose_mm m))) -> W tau^-1 sin(tau) Wt X *)\n",
"let b = gemm mm (gemm m_tau_1 ( gemm m_sin_tau (gemm transpose_mm m)));;\n",
"\n",
2020-04-24 17:07:06 +02:00
"(* Somme de 2 matrices, ici -> a + b -> R *)\n",
"let m_r = Mat.add a b;; (* Matrice de rotation R *)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Localisation des orbitales par rotation de paires d'orbitales\n",
"\n",
"Ref :\n",
"Edmiston, C., & Ruedenberg, K. (1963). Localized Atomic and Molecular Orbitals.\n",
"Reviews of Modern Physics, 35(3), 457– 464. doi:10.1103/revmodphys.35.457 \n",
"\n",
"\n",
"Méthode :\n",
"\n",
"On va créer des nouvelles orbitales i~ et j~ à partir des orbitales i et j par combinaison linéaire de ces dernières tel que :\n",
"\n",
" i~ (x) = cos(gamma) i(x) - sin(gamma) j(x)\n",
" j~ (x) = sin(gamma) i(x) - cos(gamma) j(x)\n",
"\n",
"\n",
"On part de la matrices de orbitales moléculaires Phi et on cherche la paire d'orbitale (i,j) ayant le plus grand angle de rotation alpha, avec alpha défini comme :\n",
"\n",
" cos(4 alpha) = -A_12/(A²_12 + B²_12)^(1/2)\n",
" <=> alpha = (1/4) acos {-A_12/(A²_12 + B²_12)^(1/2)}\n",
"\n",
" sin(4 alpha) = B_12/(A²_12 + B²_12)^(1/2)\n",
" <=> alpha = (1/4) asin {B_12/(A²_12 + B²_12)^(1/2)}\n",
"\n",
" tan(4 alpha) = -B_12/A_12\n",
" <=> alpha = (1/4) atan {-B_12/A_12}\n",
"\n",
"Avec : \n",
" A_12 = ...\n",
" B_12 = ...\n",
2020-04-27 08:17:19 +02:00
"\n",
2020-04-24 17:07:06 +02:00
"/ *\n",
"Dans la démonstration de Michel les définitions de B(theta), A_ij et B_ij sont claires, mais j'ai du mal avec les définitions utilisées par Edmiston, C., & Ruedenberg, K. Je pense que je comprend mal la notation car je ne vois pas comment les retrouver en partant de la définition de D(phi) et de la définition des nouvelles orbitales créées par la rotation des anciennes.\n",
"\n",
"D(phi) est défini tel que : \n",
" \n",
" D(phi) = Somme sur n de [ phi²_n | phi²_n ]\n",
"\n",
"Le but est de trouvé une transformation :\n",
" \n",
" λ_v(x) = Somme sur n de phi_n(x) T_nv\n",
" \n",
"tel que : \n",
"\n",
" D(λ) = Somme sur v de [λ²_v|λ²_v]\n",
" \n",
"Afin de maximiser D.\n",
"\n",
"Cas 2D:\n",
"\n",
" i~ (x) = cos(gamma) i(x) - sin(gamma) j(x)\n",
" j~ (x) = sin(gamma) i(x) - cos(gamma) j(x)\n",
"\n",
" ? => ? D(~) = D(gamma) + A_12 + ( A²_12 + B²_12 )^(1/2) cos 4(gamma-alpha)\n",
"\n",
2020-04-27 08:17:19 +02:00
"Là je ne vois pas le passage, mais la def de D(phi) me gêne, cela veut bien dire :\n",
" \n",
" D(phi) = Somme sur n de < phi²_n | phi²_n > ?\n",
2020-04-24 17:07:06 +02:00
"\n",
2020-04-27 08:17:19 +02:00
"Et je ne vois pas en quoi maximiser D localise les OMs sachant qur la position moyenne des OMs est définie par \n",
" \n",
" <phi|r|phi>\n",
" \n",
2020-04-24 17:07:06 +02:00
"* /\n",
"\n",
"\n",
"\n",
"\n",
"On extrait de la matrice des OMs les orbitales i et j (vecteurs colonnes) pour former une nouvelle matrice Ksi de dimension n * 2. \n",
"\n",
"Pour effectuer la rotation des orbitales i et j on utilise la matrice de rotation R pour la rotation de 2 orbitales, qui est définie comme :\n",
"\n",
"R = ( cos(alpha) -sin(aplha) )\n",
" ( sin(alpha) cos(alpha) )\n",
" \n",
"On applique R à Ksi : R Ksi = Ksi~ \n",
"\n",
"On obtient Ksi~ la matrice contenant les deux nouvelles OMs i~ et j~ obtenues par rotation de i et j.\n",
"\n",
2020-04-27 08:17:19 +02:00
"On réinjecte ces deux nouvelles orbitales i~ et j~ à la place des anciennes orbitales i et j dans la matrice des OMs Phi, ce qui nous donne une nouvelle matrice des OMs Phi~. Pour cela on créer des matrices intérmédiaires:\n",
" - une matrice (m_ksi) n par n avec tous ses éléments nuls sauf les colonnes qui contiennent les OMs i et j \n",
" - une matrice (m_ksi_tilde) n par n avec tous ses éléments nuls sauf les colonnes qui contiennent les OMs i~ et j~\n",
"Ainsi, on soustrait à la matrice des OMs Phi la matrice m_ksi pour supprimer les OMs i et j de celle ci puis on additionne cette nouvelle matrice à la matrice m_ksi_tilde pour créer la nouvelle matrice des OMs Phi~.\n",
2020-04-24 17:07:06 +02:00
"\n",
"On repart de cette nouvelle matrice Phi~ et on cherche la paire d'orbitale (k,l) ayant le plus grand angle de rotation alpha. Et on procède comme nous l'avons précedemment de manière intérative. (Critère de convergence ? sur alpha ?)\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"let a= 1.;;\n",
"\n",
"(* Matrice de rotation 2*2 *)\n",
"(*let rot = Mat.init_cols 2 2 (fun i j -> match (i,j) with\n",
" | (1,1) -> cos a\n",
" | (2,2) -> cos a\n",
" | (2,1) -> sin a\n",
" | (1,2) -> -. sin a );;*)\n",
" \n",
"let rot = Mat.init_cols 2 2 (fun i j -> if i=j then cos a\n",
" else if i>j then sin a \n",
" else -. sin a );;\n",
"\n",
2020-04-27 08:17:19 +02:00
"(* Fonction d'extraction des 2 vecteurs propres dans la matrice (Phi~) n par 2 pour appliquer R afin d'effectuer\n",
"la rotation des orbitales *)\n",
2020-04-24 17:07:06 +02:00
"ran.{1,2};; (*{1,2} -> 1ere ligne, 2e colonne*)\n",
"let p = 1;;\n",
"let q = 2;;\n",
2020-04-27 08:17:19 +02:00
"let ksi = Mat.init_cols n 2 (fun i j -> if j=1 then ran.{i,p} else ran.{i,q} );;"
2020-04-24 17:07:06 +02:00
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* Fonction de calcul de ksi~ *)\n",
"let ksi_tilde = gemm ksi rot;;"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"(* Pour la réinjection on créer des matrices intérmédiares, une matrice nulle partout sauf sur \n",
"les colonnes de i et j et de i~ et j~. On fait la différence de la première matrice avec la matrice\n",
"des OMs Phi afin de substituer les colonnes de i et j par des zéro et ensuite sommer cette matrice avec \n",
"celle contenant i~ et j~ *)\n",
"\n",
"(* Matrice intérmédiare pour l'injection de ksi~ *)\n",
"let m_ksi_tilde = Mat.init_cols n n (fun i j -> if j=q then ksi_tilde.{i,p}\n",
" else if j=p then ksi_tilde.{i,q}\n",
" else 0.);;\n",
"(* Matrice intermédiaire pour supprimer ksi *) \n",
"let m_ksi = Mat.init_cols n n (fun i j -> if j=q then ksi.{i,p}\n",
" else if j=p then ksi.{i,q}\n",
" else 0.);;\n",
"(* Test soustraction -> problème de type sur new_ran après*)\n",
"let test = Mat.sub ran m_ksi;;\n",
"\n",
2020-04-27 08:17:19 +02:00
"(* Construction de la nouvelle matrice d'OMs phi~ -> Problème *)\n",
2020-04-24 17:07:06 +02:00
"let new_ran = Mat.sum m_ksi_tilde test;; "
2020-04-24 00:04:21 +02:00
]
2020-04-23 11:25:03 +02:00
}
],
"metadata": {
"kernelspec": {
"display_name": "OCaml 4.10.0",
"language": "OCaml",
"name": "ocaml-jupyter"
},
"language_info": {
"codemirror_mode": "text/x-ocaml",
"file_extension": ".ml",
"mimetype": "text/x-ocaml",
"name": "OCaml",
"nbconverter_exporter": null,
"pygments_lexer": "OCaml",
"version": "4.10.0"
}
},
"nbformat": 4,
"nbformat_minor": 4
}