scilab/modules/elementary_functions/help/fr_FR/ndgrid.xml

   1 <?xml version="1.0" encoding="UTF-8"?>\r
   2 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns5="http://www.w3.org/1999/xhtml" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org"  xml:id="ndgrid" xml:lang="fr">\r
   3     <refnamediv>\r
   4         <refname>ndgrid</refname>\r
   5         <refpurpose>construit des matrices ou hypermatrices en répliquant des vecteurs\r
   6         </refpurpose>\r
   7     </refnamediv>\r
   8     <refsynopsisdiv>\r
   9         <title>Séquences d'appel</title>\r
  10         <synopsis>[X, Y] = ndgrid(x,y)\r
  11             [X, Y, Z] = ndgrid(x,y,z)\r
  12             [X, Y, Z, T] = ndgrid(x,y,z,t)\r
  13             [X1, X2, ..., Xm] = ndgrid(x1,x2,...,xm)\r
  14         </synopsis>\r
  15     </refsynopsisdiv>\r
  16     <refsection role="arguments">\r
  17         <title>Paramètres</title>\r
  18         <variablelist>\r
  19             <varlistentry>\r
  20                 <term>x, y, z, ...</term>\r
  21                 <listitem>\r
  22                     <para>vecteurs de types simples quelconques possiblement\r
  23                     distincts (booléens, \r
  24                     entiers encodés, décimaux, complexes, polynômes, rationnels,\r
  25                     textes).</para>\r
  26                 </listitem>\r
  27             </varlistentry>\r
  28             <varlistentry>\r
  29                 <term>X, Y, Z, ...</term>\r
  30                 <listitem>\r
  31                     <para>Matrices (si seulement 2 vecteurs d'entrée),\r
  32                     ou hypermatrices avec autant de dimensions qu'il y a de \r
  33                     vecteurs d'entrée <literal>x1, x2, ..., xn</literal>.\r
  34                     <varname>X</varname> a le type de <varname>x</varname> ; \r
  35                     <varname>Y</varname> a le type de <varname>y</varname> ; \r
  36                     etc. \r
  37                     </para>\r
  38                 </listitem>\r
  39             </varlistentry>\r
  40         </variablelist>\r
  41     </refsection>\r
  42     <refsection role="description">\r
  43         <title>Description</title>\r
  44         <para>La première application de <function>ndgrid</function> consiste à\r
  45             construire une grille multidimensionnelle de noeuds échantillonnant\r
  46             l'espace 2D ou 3D ou N-D, à partir de 2, 3 ou N vecteurs \r
  47             <literal>x</literal>, <literal> y</literal>, etc.. indiquant \r
  48             l'échantillonage de chaque direction de l'espace.\r
  49         </para>\r
  50         <para>Pour ce faire, \r
  51             <itemizedlist>\r
  52                 <listitem></listitem>la matrice ou l'hypermatrice <literal>X</literal> \r
  53                 est construite en répliquant le vecteur  <literal>x</literal> \r
  54                 dans toutes ses colonnes ;\r
  55                 </listitem> \r
  56                 <listitem>la matrice ou l'hypermatrice <literal>Y</literal> \r
  57                 est construite en répliquant le vecteur  <literal>y</literal> \r
  58                 dans toutes ses lignes ;\r
  59                 </listitem> \r
  60                 <listitem>la matrice ou l'hypermatrice <literal>Z</literal> \r
  61                 est construite en répliquant le vecteur  <literal>z</literal> \r
  62                 en épaisseur pour tous les points (x,y) ; \r
  63                 etc.\r
  64                 </listitem>\r
  65             </itemizedlist>\r
  66         </para>\r
  67         <screen>\r
  68 <![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
  69  X  = \r
  70    1.   1.   1.   1.\r
  71    3.   3.   3.   3.\r
  72    4.   4.   4.   4.\r
  73 \r
  74    Y  = \r
  75    0.   2.   4.   6.\r
  76    0.   2.   4.   6.\r
  77    0.   2.   4.   6.\r
  78 ]]></screen>\r
  79         <para>\r
  80             Les coordonnées du noeud node(i,j) dans l'espace 2D seront alors \r
  81             simplement <literal>[x(i), y(j)]</literal> maintenant données par\r
  82             <literal>[X(i,j), Y(i,j)]</literal>. De même, les coordonnées du noeud\r
  83             <literal>node(i,j,k)</literal> dans une grille 3D seront\r
  84             <literal>[x(i), y(j), z(k)]</literal> données par\r
  85             <literal>[X(i,j,k), Y(i,j,k), Z(i,j,k)]</literal>.\r
  86         </para>\r
  87         <para>Ce schéma de construction par réplication peut être utilisé\r
  88         pour construire une grille à un nombre N quelconque de dimensions.\r
  89         Par ailleurs, il est indépendant de la nature des vecteurs de base répliqués\r
  90         et peut donc être utilisé pour tous les types de données uniformes.\r
  91         A titre d'exemple, considérons un ensemble d'objets ayant tous 2 attributs :\r
  92             <orderedlist>\r
  93                 <listitem>Le premier est un nombre <literal>n</literal>, \r
  94                 avec 2 valeurs possibles, par exemple: <literal>n = [ 3 7 ]</literal>\r
  95                 </listitem>\r
  96                 <listitem>Le second est une lettre, avec 6 choix possibles, \r
  97                 par exemple: <literal>c = ["a" "e" "i" "o" "u" "y"]</literal>\r
  98                 </listitem>\r
  99             </orderedlist>\r
 100             Nous souhaitons maintenant générer l'ensemble complet des \r
 101             objets {n,c} possibles. Il s'agit juste d'une grille 2D \r
 102             d'<literal>objets</literal> :\r
 103         </para>\r
 104         <screen>\r
 105 <![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
 106  X  = \r
 107    1.   1.   1.   1.\r
 108    3.   3.   3.   3.\r
 109    4.   4.   4.   4.\r
 110 \r
 111    Y  = \r
 112    0.   2.   4.   6.\r
 113    0.   2.   4.   6.\r
 114    0.   2.   4.   6.\r
 115 ]]></screen>\r
 116         <para>De là, l'objet(i,j) aura les attributs\r
 117         <literal>{n(i) c(j)}</literal> que l'on pourra maintenant désigner par \r
 118         <literal>{N(i,j) C(i,j)}</literal>.\r
 119         Ce type de grille pourra être utilisée pour initialiser un tableau \r
 120         2D de structures ayant 2 champs <literal>n</literal> et <literal>c</literal>.\r
 121         </para>\r
 122         <para>Les exemples suivants montrent comment utiliser les matrices ou\r
 123         hypermatrices <varname>X, Y, Z</varname> produites, pour des applications\r
 124         usuelles.\r
 125         </para> \r
 126     </refsection>\r
 127     <refsection role="examples">\r
 128         <title>Exemples</title>\r
 129 \r
 130         <para><emphasis role="bold">Exemple #1:</emphasis> </para>\r
 131         <programlisting role="example"><![CDATA[  \r
 132 // Créons une grille de points {X,Y}\r
 133 x = linspace(-10,2,40);\r
 134 y = linspace(-5,5,40);\r
 135 [X,Y] = ndgrid(x,y); // x et y sont répliqués pour créer la grille\r
 136 \r
 137 // Calculons des ordonnées Z(X,Y) et traçons Z(X,Y) :\r
 138 Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
 139 clf()\r
 140 plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
 141  ]]></programlisting>\r
 142         <scilab:image>\r
 143             x = linspace(-10,2,40);\r
 144             y = linspace(-5,5,40);\r
 145             [X,Y] = ndgrid(x,y);\r
 146             Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
 147             clf()\r
 148             plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
 149         </scilab:image>\r
 150 \r
 151         <para><emphasis role="bold">Exemple #2:</emphasis> </para>\r
 152         <programlisting role="example"><![CDATA[  \r
 153 // Créons une grille en 3 dimensions\r
 154 nx = 10; ny = 6; nz = 4;\r
 155 x = linspace(0,2,nx);\r
 156 y = linspace(0,1,ny);\r
 157 z = linspace(0,0.5,nz);\r
 158 [X,Y,Z] = ndgrid(x,y,z);\r
 159 \r
 160 // Nous choisissons ici une représentation cartésienne, mais l'on pourrait\r
 161 // aussi travailler en coordonnées cylindriques, sphériques, ou autres. \r
 162 // Transformons les coordonnées pour plot3d() :\r
 163 XF=[]; YF=[]; ZF=[];\r
 164 \r
 165 for k=1:nz\r
 166    [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
 167    XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
 168 end\r
 169 \r
 170 for j=1:ny\r
 171    [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
 172                      matrix(Y(:,j,:),[nx,nz]),...\r
 173                      matrix(Z(:,j,:),[nx,nz]));\r
 174    XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
 175 end\r
 176 \r
 177 // Affichage :\r
 178 clf()\r
 179 plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
 180 xtitle("A 3d grid !"); show_window()\r
 181  ]]></programlisting>\r
 182         <scilab:image>\r
 183             nx = 10; ny = 6; nz = 4;\r
 184             x = linspace(0,2,nx);\r
 185             y = linspace(0,1,ny);\r
 186             z = linspace(0,0.5,nz);\r
 187             [X,Y,Z] = ndgrid(x,y,z);\r
 188             \r
 189             XF=[]; YF=[]; ZF=[];\r
 190             \r
 191             for k=1:nz\r
 192             [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
 193             XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
 194             end\r
 195             \r
 196             for j=1:ny\r
 197             [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
 198             matrix(Y(:,j,:),[nx,nz]),...\r
 199             matrix(Z(:,j,:),[nx,nz]));\r
 200             XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
 201             end\r
 202             plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
 203             xtitle("A 3d grid !"); \r
 204         </scilab:image>\r
 205         <para><emphasis role="bold">Exemple #3: création d'une table de digrammes</emphasis> </para>\r
 206         <programlisting role="example"><![CDATA[  \r
 207 [c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
 208 c1+c2\r
 209  ]]></programlisting>\r
 210     <screen>\r
 211 <![CDATA[--> [c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
 212  c2  = \r
 213 !a  b  c  d  e  f  g  h  !\r
 214 !a  b  c  d  e  f  g  h  !\r
 215 !a  b  c  d  e  f  g  h  !\r
 216 \r
 217  c1  = \r
 218 !a  a  a  a  a  a  a  a  !\r
 219 !b  b  b  b  b  b  b  b  !\r
 220 !c  c  c  c  c  c  c  c  !\r
 221 \r
 222 --> c1+c2\r
 223  ans  =\r
 224 !aa  ab  ac  ad  ae  af  ag  ah  !\r
 225 !ba  bb  bc  bd  be  bf  bg  bh  !\r
 226 !ca  cb  cc  cd  ce  cf  cg  ch  !\r
 227 ]]></screen>\r
 228     </refsection>\r
 229     <refsection role="see also">\r
 230         <title>Voir aussi</title>\r
 231         <simplelist type="inline">\r
 232             <member>\r
 233                 <link linkend="meshgrid">meshgrid</link>\r
 234             </member>\r
 235             <member>\r
 236                 <link linkend="kron">kron</link>\r
 237             </member>\r
 238             <member>\r
 239                 <link linkend="feval">feval</link>\r
 240             </member>\r
 241             <member>\r
 242                 <link linkend="eval3d">eval3d</link>\r
 243             </member>\r
 244             <member>\r
 245                 <link linkend="nf3d">nf3d</link>\r
 246             </member>\r
 247         </simplelist>\r
 248     </refsection>\r
 249     <refsection role="history">\r
 250         <title>Historique</title>\r
 251         <revhistory>\r
 252             <revision>\r
 253                 <revnumber>6.0</revnumber>\r
 254                 <revdescription>Extension à tous les types de données uniformes ([], booleans, encoded integers, polynomials, rationals, strings). Révision de la page d'aide.\r
 255                 </revdescription>\r
 256             </revision>\r
 257         </revhistory>\r
 258     </refsection>\r
 259 </refentry>\r