* Bug #14025 fixed - Extend ndgrid() to any homogeneous data type 12/17812/2
Samuel GOUGEON [Tue, 23 Feb 2016 09:25:04 +0000 (10:25 +0100)]
booleans, integers, polynomials, rationals, strings, [] are managed.

Change-Id: I6b49b3a1cdec730bf89d8fa991bc7f718fbc79f1

scilab/CHANGES
scilab/modules/elementary_functions/help/en_US/ndgrid.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/fr_FR/ndgrid.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/ja_JP/ndgrid.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/pt_BR/ndgrid.xml [new file with mode: 0644]
scilab/modules/elementary_functions/help/ru_RU/ndgrid.xml [new file with mode: 0644]
scilab/modules/elementary_functions/macros/ndgrid.sci

index 61ac987..9247b80 100644 (file)
@@ -300,6 +300,8 @@ Bug Fixes
 
 * Bug #14433 fixed - acoth (which call atanh) crash scilab
 
+* Bug #14035 fixed - ndgrid did not manage all homogeneous data type (booleans, integers, polynomials, rationals, strings, [])
+
 In 6.0.0 beta-1:
 
 * Bug #6057 fixed  - trailing space after minus sign has been removed from the display of values
diff --git a/scilab/modules/elementary_functions/help/en_US/ndgrid.xml b/scilab/modules/elementary_functions/help/en_US/ndgrid.xml
new file mode 100644 (file)
index 0000000..ae8e5e2
--- /dev/null
@@ -0,0 +1,241 @@
+<?xml version="1.0" encoding="UTF-8"?>\r
+<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="en">\r
+    <refnamediv>\r
+        <refname>ndgrid</refname>\r
+        <refpurpose>build matrices or N-D arrays by replicating some template vectors\r
+        </refpurpose>\r
+    </refnamediv>\r
+    <refsynopsisdiv>\r
+        <title>Calling Sequence</title>\r
+        <synopsis>[X, Y] = ndgrid(x,y)\r
+            [X, Y, Z] = ndgrid(x,y,z)\r
+            [X, Y, Z, T] = ndgrid(x,y,z,t)\r
+            [X1, X2, ..., Xm] = ndgrid(x1,x2,...,xm)\r
+        </synopsis>\r
+    </refsynopsisdiv>\r
+    <refsection role="arguments">\r
+        <title>Arguments</title>\r
+        <variablelist>\r
+            <varlistentry>\r
+                <term>x, y, z, ...</term>\r
+                <listitem>\r
+                    <para>vectors of any data types. They may have distinct data types.</para>\r
+                </listitem>\r
+            </varlistentry>\r
+            <varlistentry>\r
+                <term>X, Y, Z, ...</term>\r
+                <listitem>\r
+                    <para>matrices in case of 2 input arguments, or hypermatrices otherwise.\r
+                    They all have the same sizes: size(X,"*") rows, size(Y,"*") columns, \r
+                        size(Z,"*") layers, etc. \r
+                        They have the datatypes of respective input vectors:\r
+                        <literal>typeof(X)==typeof(x)</literal>, \r
+                        <literal>typeof(Y)==typeof(y)</literal>, etc.\r
+                    </para>\r
+                </listitem>\r
+            </varlistentry>\r
+        </variablelist>\r
+    </refsection>\r
+    <refsection role="description">\r
+        <title>Description</title>\r
+        <para>The first application of <function>ndgrid</function> is to build\r
+            a grid of nodes meshing the 2D or 3D or N-D space according to 2, 3,\r
+            or more sets\r
+            <literal>x</literal>, <literal> y</literal>, etc.. of  \r
+            "template" coordinates sampled along each direction/dimension of the\r
+            space that you want to mesh.\r
+        </para>\r
+        <para>Hence, the matrix or hypermatrix <literal>X</literal> is made\r
+            by replicating the vector <literal>x</literal> as all its columns ; \r
+            the matrix or hypermatrix <literal>Y</literal> is made\r
+            by replicating the vector <literal>y</literal> as all its rows ;\r
+            <literal>Z</literal> is made of replicating the vector \r
+            <literal>z</literal> along all its local thicknesses (3rd dimension); \r
+            etc\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
+ X  = \r
+   1.   1.   1.   1.\r
+   3.   3.   3.   3.\r
+   4.   4.   4.   4.\r
+\r
+   Y  = \r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+]]></screen>\r
+        <para>  \r
+            Then, the coordinates of the node(i,j) in the 2D space \r
+            will be\r
+            simply <literal>[x(i), y(j)]</literal> now given by\r
+            <literal>[X(i,j), Y(i,j)]</literal>. As well, the coordinates of a\r
+            <literal>node(i,j,k)</literal> of a 3D grid will be \r
+            <literal>[x(i), y(j), z(k)]</literal> now given by \r
+            <literal>[X(i,j,k), Y(i,j,k), Z(i,j,k)]</literal>.\r
+        </para>\r
+        <para>\r
+            This replication scheme can be generalized to any number of dimensions,\r
+            as well to any type of uniform data. Let's for instance consider 2\r
+            attributes:\r
+            <orderedlist>\r
+                <listitem>The first is a number, to be chosen from the vector say\r
+                <literal>n = [ 3 7 ]</literal>\r
+                </listitem>\r
+                <listitem>The second is a letter, to be chosen from the vector \r
+                say <literal>c = ["a" "e" "i" "o" "u" "y"]</literal>\r
+                </listitem>\r
+            </orderedlist>\r
+            Then we want to build the set of all {n,c} possible pairs. It will\r
+            just be the 2D grid:\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [N, C] = ndgrid([3 7],["a" "e" "i" "o" "u" "y"])\r
+ C  = \r
+!a  e  i  o  u  y  !\r
+!a  e  i  o  u  y  !\r
+\r
+ N  = \r
+   3.   3.   3.   3.   3.   3.\r
+   7.   7.   7.   7.   7.   7.\r
+]]></screen>\r
+        <para>Then, the object(i,j) will have the properties \r
+        <literal>{n(i) c(j)}</literal> that now can be addressed with\r
+        <literal>{N(i,j) C(i,j)}</literal>.\r
+        This kind of grid may be useful to initialize an array of structures.\r
+        </para>\r
+        <para>Following examples show how to use <varname>X, Y, Z</varname> in\r
+        most frequent applications.\r
+        </para> \r
+    </refsection>\r
+    <refsection role="examples">\r
+        <title>Examples</title>\r
+        <para><emphasis role="bold">Example #1:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+// Create a simple 2d grid\r
+x = linspace(-10,2,40);\r
+y = linspace(-5,5,40);\r
+[X,Y] = ndgrid(x,y);\r
+\r
+// Compute ordinates Z(X,Y) on the {X, Y} grid and plot Z(X,Y)\r
+Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+clf()\r
+plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image>\r
+        x = linspace(-10,2,40);\r
+        y = linspace(-5,5,40);\r
+        [X,Y] = ndgrid(x,y);\r
+        Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+        clf()\r
+        plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+        </scilab:image>\r
+        <para><emphasis role="bold">Example #2:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+// Create a simple 3d grid\r
+nx = 10; ny = 6; nz = 4;\r
+x = linspace(0,2,nx);\r
+y = linspace(0,1,ny);\r
+z = linspace(0,0.5,nz);\r
+[X,Y,Z] = ndgrid(x,y,z);\r
+\r
+// Try to display this 3d grid ...\r
+XF=[]; YF=[]; ZF=[];\r
+\r
+for k=1:nz\r
+   [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+\r
+for j=1:ny\r
+   [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+                     matrix(Y(:,j,:),[nx,nz]),...\r
+                     matrix(Z(:,j,:),[nx,nz]));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+\r
+clf()\r
+plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61,leg="X@Y@Z")\r
+xtitle("A 3d grid !"); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image>\r
+            nx = 10; ny = 6; nz = 4;\r
+            x = linspace(0,2,nx);\r
+            y = linspace(0,1,ny);\r
+            z = linspace(0,0.5,nz);\r
+            [X,Y,Z] = ndgrid(x,y,z);\r
+            \r
+            XF=[]; YF=[]; ZF=[];\r
+            \r
+            for k=1:nz\r
+            [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            \r
+            for j=1:ny\r
+            [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+            matrix(Y(:,j,:),[nx,nz]),...\r
+            matrix(Z(:,j,:),[nx,nz]));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+            xtitle("A 3d grid !"); \r
+        </scilab:image>\r
+\r
+        <para><emphasis role="bold">Example #3: Creates a table of digrams:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+[c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+c1+c2\r
+ ]]></programlisting>\r
+    <screen>\r
+<![CDATA[--> [c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+ c2  = \r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+\r
+ c1  = \r
+!a  a  a  a  a  a  a  a  !\r
+!b  b  b  b  b  b  b  b  !\r
+!c  c  c  c  c  c  c  c  !\r
+\r
+--> c1+c2\r
+ ans  =\r
+!aa  ab  ac  ad  ae  af  ag  ah  !\r
+!ba  bb  bc  bd  be  bf  bg  bh  !\r
+!ca  cb  cc  cd  ce  cf  cg  ch  !\r
+]]></screen>\r
+    </refsection>\r
+    <refsection role="see also">\r
+        <title>See Also</title>\r
+        <simplelist type="inline">\r
+            <member>\r
+                <link linkend="meshgrid">meshgrid</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="kron">kron</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="feval">feval</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="eval3d">eval3d</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="nf3d">nf3d</link>\r
+            </member>\r
+        </simplelist>\r
+    </refsection>\r
+    <refsection role="history">\r
+        <title>History</title>\r
+        <revhistory>\r
+            <revision>\r
+                <revnumber>6.0</revnumber>\r
+                <revdescription>Extension to all homogeneous datatypes ([], \r
+                booleans, encoded integers, polynomials, rationals, strings). \r
+                Revision of the help page.\r
+                </revdescription>\r
+            </revision>\r
+        </revhistory>\r
+    </refsection>\r
+</refentry>\r
diff --git a/scilab/modules/elementary_functions/help/fr_FR/ndgrid.xml b/scilab/modules/elementary_functions/help/fr_FR/ndgrid.xml
new file mode 100644 (file)
index 0000000..a689b2d
--- /dev/null
@@ -0,0 +1,259 @@
+<?xml version="1.0" encoding="UTF-8"?>\r
+<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
+    <refnamediv>\r
+        <refname>ndgrid</refname>\r
+        <refpurpose>construit des matrices ou hypermatrices en répliquant des vecteurs\r
+        </refpurpose>\r
+    </refnamediv>\r
+    <refsynopsisdiv>\r
+        <title>Séquences d'appel</title>\r
+        <synopsis>[X, Y] = ndgrid(x,y)\r
+            [X, Y, Z] = ndgrid(x,y,z)\r
+            [X, Y, Z, T] = ndgrid(x,y,z,t)\r
+            [X1, X2, ..., Xm] = ndgrid(x1,x2,...,xm)\r
+        </synopsis>\r
+    </refsynopsisdiv>\r
+    <refsection role="arguments">\r
+        <title>Paramètres</title>\r
+        <variablelist>\r
+            <varlistentry>\r
+                <term>x, y, z, ...</term>\r
+                <listitem>\r
+                    <para>vecteurs de types simples quelconques possiblement\r
+                    distincts (booléens, \r
+                    entiers encodés, décimaux, complexes, polynômes, rationnels,\r
+                    textes).</para>\r
+                </listitem>\r
+            </varlistentry>\r
+            <varlistentry>\r
+                <term>X, Y, Z, ...</term>\r
+                <listitem>\r
+                    <para>Matrices (si seulement 2 vecteurs d'entrée),\r
+                    ou hypermatrices avec autant de dimensions qu'il y a de \r
+                    vecteurs d'entrée <literal>x1, x2, ..., xn</literal>.\r
+                    <varname>X</varname> a le type de <varname>x</varname> ; \r
+                    <varname>Y</varname> a le type de <varname>y</varname> ; \r
+                    etc. \r
+                    </para>\r
+                </listitem>\r
+            </varlistentry>\r
+        </variablelist>\r
+    </refsection>\r
+    <refsection role="description">\r
+        <title>Description</title>\r
+        <para>La première application de <function>ndgrid</function> consiste à\r
+            construire une grille multidimensionnelle de noeuds échantillonnant\r
+            l'espace 2D ou 3D ou N-D, à partir de 2, 3 ou N vecteurs \r
+            <literal>x</literal>, <literal> y</literal>, etc.. indiquant \r
+            l'échantillonage de chaque direction de l'espace.\r
+        </para>\r
+        <para>Pour ce faire, \r
+            <itemizedlist>\r
+                <listitem></listitem>la matrice ou l'hypermatrice <literal>X</literal> \r
+                est construite en répliquant le vecteur  <literal>x</literal> \r
+                dans toutes ses colonnes ;\r
+                </listitem> \r
+                <listitem>la matrice ou l'hypermatrice <literal>Y</literal> \r
+                est construite en répliquant le vecteur  <literal>y</literal> \r
+                dans toutes ses lignes ;\r
+                </listitem> \r
+                <listitem>la matrice ou l'hypermatrice <literal>Z</literal> \r
+                est construite en répliquant le vecteur  <literal>z</literal> \r
+                en épaisseur pour tous les points (x,y) ; \r
+                etc.\r
+                </listitem>\r
+            </itemizedlist>\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
+ X  = \r
+   1.   1.   1.   1.\r
+   3.   3.   3.   3.\r
+   4.   4.   4.   4.\r
+\r
+   Y  = \r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+]]></screen>\r
+        <para>\r
+            Les coordonnées du noeud node(i,j) dans l'espace 2D seront alors \r
+            simplement <literal>[x(i), y(j)]</literal> maintenant données par\r
+            <literal>[X(i,j), Y(i,j)]</literal>. De même, les coordonnées du noeud\r
+            <literal>node(i,j,k)</literal> dans une grille 3D seront\r
+            <literal>[x(i), y(j), z(k)]</literal> données par\r
+            <literal>[X(i,j,k), Y(i,j,k), Z(i,j,k)]</literal>.\r
+        </para>\r
+        <para>Ce schéma de construction par réplication peut être utilisé\r
+        pour construire une grille à un nombre N quelconque de dimensions.\r
+        Par ailleurs, il est indépendant de la nature des vecteurs de base répliqués\r
+        et peut donc être utilisé pour tous les types de données uniformes.\r
+        A titre d'exemple, considérons un ensemble d'objets ayant tous 2 attributs :\r
+            <orderedlist>\r
+                <listitem>Le premier est un nombre <literal>n</literal>, \r
+                avec 2 valeurs possibles, par exemple: <literal>n = [ 3 7 ]</literal>\r
+                </listitem>\r
+                <listitem>Le second est une lettre, avec 6 choix possibles, \r
+                par exemple: <literal>c = ["a" "e" "i" "o" "u" "y"]</literal>\r
+                </listitem>\r
+            </orderedlist>\r
+            Nous souhaitons maintenant générer l'ensemble complet des \r
+            objets {n,c} possibles. Il s'agit juste d'une grille 2D \r
+            d'<literal>objets</literal> :\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
+ X  = \r
+   1.   1.   1.   1.\r
+   3.   3.   3.   3.\r
+   4.   4.   4.   4.\r
+\r
+   Y  = \r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+]]></screen>\r
+        <para>De là, l'objet(i,j) aura les attributs\r
+        <literal>{n(i) c(j)}</literal> que l'on pourra maintenant désigner par \r
+        <literal>{N(i,j) C(i,j)}</literal>.\r
+        Ce type de grille pourra être utilisée pour initialiser un tableau \r
+        2D de structures ayant 2 champs <literal>n</literal> et <literal>c</literal>.\r
+        </para>\r
+        <para>Les exemples suivants montrent comment utiliser les matrices ou\r
+        hypermatrices <varname>X, Y, Z</varname> produites, pour des applications\r
+        usuelles.\r
+        </para> \r
+    </refsection>\r
+    <refsection role="examples">\r
+        <title>Exemples</title>\r
+\r
+        <para><emphasis role="bold">Exemple #1:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+// Créons une grille de points {X,Y}\r
+x = linspace(-10,2,40);\r
+y = linspace(-5,5,40);\r
+[X,Y] = ndgrid(x,y); // x et y sont répliqués pour créer la grille\r
+\r
+// Calculons des ordonnées Z(X,Y) et traçons Z(X,Y) :\r
+Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+clf()\r
+plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image>\r
+            x = linspace(-10,2,40);\r
+            y = linspace(-5,5,40);\r
+            [X,Y] = ndgrid(x,y);\r
+            Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+            clf()\r
+            plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+        </scilab:image>\r
+\r
+        <para><emphasis role="bold">Exemple #2:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+// Créons une grille en 3 dimensions\r
+nx = 10; ny = 6; nz = 4;\r
+x = linspace(0,2,nx);\r
+y = linspace(0,1,ny);\r
+z = linspace(0,0.5,nz);\r
+[X,Y,Z] = ndgrid(x,y,z);\r
+\r
+// Nous choisissons ici une représentation cartésienne, mais l'on pourrait\r
+// aussi travailler en coordonnées cylindriques, sphériques, ou autres. \r
+// Transformons les coordonnées pour plot3d() :\r
+XF=[]; YF=[]; ZF=[];\r
+\r
+for k=1:nz\r
+   [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+\r
+for j=1:ny\r
+   [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+                     matrix(Y(:,j,:),[nx,nz]),...\r
+                     matrix(Z(:,j,:),[nx,nz]));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+\r
+// Affichage :\r
+clf()\r
+plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+xtitle("A 3d grid !"); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image>\r
+            nx = 10; ny = 6; nz = 4;\r
+            x = linspace(0,2,nx);\r
+            y = linspace(0,1,ny);\r
+            z = linspace(0,0.5,nz);\r
+            [X,Y,Z] = ndgrid(x,y,z);\r
+            \r
+            XF=[]; YF=[]; ZF=[];\r
+            \r
+            for k=1:nz\r
+            [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            \r
+            for j=1:ny\r
+            [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+            matrix(Y(:,j,:),[nx,nz]),...\r
+            matrix(Z(:,j,:),[nx,nz]));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+            xtitle("A 3d grid !"); \r
+        </scilab:image>\r
+        <para><emphasis role="bold">Exemple #3: création d'une table de digrammes</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+[c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+c1+c2\r
+ ]]></programlisting>\r
+    <screen>\r
+<![CDATA[--> [c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+ c2  = \r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+\r
+ c1  = \r
+!a  a  a  a  a  a  a  a  !\r
+!b  b  b  b  b  b  b  b  !\r
+!c  c  c  c  c  c  c  c  !\r
+\r
+--> c1+c2\r
+ ans  =\r
+!aa  ab  ac  ad  ae  af  ag  ah  !\r
+!ba  bb  bc  bd  be  bf  bg  bh  !\r
+!ca  cb  cc  cd  ce  cf  cg  ch  !\r
+]]></screen>\r
+    </refsection>\r
+    <refsection role="see also">\r
+        <title>Voir aussi</title>\r
+        <simplelist type="inline">\r
+            <member>\r
+                <link linkend="meshgrid">meshgrid</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="kron">kron</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="feval">feval</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="eval3d">eval3d</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="nf3d">nf3d</link>\r
+            </member>\r
+        </simplelist>\r
+    </refsection>\r
+    <refsection role="history">\r
+        <title>Historique</title>\r
+        <revhistory>\r
+            <revision>\r
+                <revnumber>6.0</revnumber>\r
+                <revdescription>Extension à tous les types de données uniformes ([], booleans, encoded integers, polynomials, rationals, strings). Révision de la page d'aide.\r
+                </revdescription>\r
+            </revision>\r
+        </revhistory>\r
+    </refsection>\r
+</refentry>\r
diff --git a/scilab/modules/elementary_functions/help/ja_JP/ndgrid.xml b/scilab/modules/elementary_functions/help/ja_JP/ndgrid.xml
new file mode 100644 (file)
index 0000000..d7d432a
--- /dev/null
@@ -0,0 +1,230 @@
+<?xml version="1.0" encoding="UTF-8"?>\r
+<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="ja">\r
+    <refnamediv>\r
+        <refname>ndgrid</refname>\r
+        <refpurpose>与えられたベクトルを複製することによって、行列またはN次元配列を作成\r
+        </refpurpose>\r
+    </refnamediv>\r
+    <refsynopsisdiv>\r
+        <title>呼び出し手順</title>\r
+        <synopsis>[X, Y] = ndgrid(x,y)\r
+            [X, Y, Z] = ndgrid(x,y,z)\r
+            [X, Y, Z, T] = ndgrid(x,y,z,t)\r
+            [X1, X2, ..., Xm] = ndgrid(x1,x2,...,xm)\r
+        </synopsis>\r
+    </refsynopsisdiv>\r
+    <refsection role="arguments">\r
+        <title>引数</title>\r
+        <variablelist>\r
+            <varlistentry>\r
+                <term>x, y, z, ...</term>\r
+                <listitem>\r
+                    <para>vectors of any data types. They may have distinct data types.</para>\r
+                </listitem>\r
+            </varlistentry>\r
+            <varlistentry>\r
+                <term>X, Y, Z, ...</term>\r
+                <listitem>\r
+                    <para>\r
+                        入力引数が2個の場合は行列,\r
+                        それ以外の場合はハイパー行列\r
+                    </para>\r
+                </listitem>\r
+            </varlistentry>\r
+        </variablelist>\r
+    </refsection>\r
+    <refsection role="description">\r
+        <title>説明</title>\r
+        <para>The first application of <function>ndgrid</function> is to build\r
+            a grid of nodes meshing the 2D or 3D or N-D space according to 2, 3,\r
+            or more sets\r
+            <literal>x</literal>, <literal> y</literal>, etc.. of  \r
+            "template" coordinates sampled along each direction/dimension of the\r
+            space that you want to mesh.\r
+        </para>\r
+        <para>Hence, the matrix or hypermatrix <literal>X</literal> is made\r
+            by replicating the vector <literal>x</literal> as all its columns ; \r
+            the matrix or hypermatrix <literal>Y</literal> is made\r
+            by replicating the vector <literal>y</literal> as all its rows ;\r
+            <literal>Z</literal> is made of replicating the vector \r
+            <literal>z</literal> along all its local thicknesses (3rd dimension); \r
+            etc\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
+ X  = \r
+   1.   1.   1.   1.\r
+   3.   3.   3.   3.\r
+   4.   4.   4.   4.\r
+\r
+   Y  = \r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+]]></screen>\r
+        <para>  \r
+            Then, the coordinates of the node(i,j) in the 2D space \r
+            will be\r
+            simply <literal>[x(i), y(j)]</literal> equal to \r
+            <literal>[X(i,j), Y(i,j)]</literal>. As well, the coordinates of a\r
+            <literal>node(i,j,k)</literal> of a 3D grid will be \r
+            <literal>[x(i), y(j), z(k)]</literal> equal to \r
+            <literal>[X(i,j,k), Y(i,j,k), Z(i,j,k)]</literal>.\r
+        </para>\r
+        <para>\r
+            This replication scheme can be generalized to any number of dimensions,\r
+            as well to any type of uniform data. Let's for instance consider 2\r
+            attributes:\r
+            <orderedlist>\r
+                <listitem>The first is a number, to be chosen from the vector say\r
+                <literal>n = [ 3 7 ]</literal>\r
+                </listitem>\r
+                <listitem>The second is a letter, to be chosen from the vector \r
+                say <literal>c = ["a" "e" "i" "o" "u" "y"]</literal>\r
+                </listitem>\r
+            </orderedlist>\r
+            Then we want to build the set of all {n,c} possible pairs. It will\r
+            just be the 2D grid:\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [N, C] = ndgrid([3 7],["a" "e" "i" "o" "u" "y"])\r
+ C  = \r
+!a  e  i  o  u  y  !\r
+!a  e  i  o  u  y  !\r
+\r
+ N  = \r
+   3.   3.   3.   3.   3.   3.\r
+   7.   7.   7.   7.   7.   7.\r
+]]></screen>\r
+        <para>Then, the object(i,j) will have the properties \r
+        <literal>{n(i) c(j)}</literal> that now can be addressed with\r
+        <literal>{N(i,j) C(i,j)}</literal>.\r
+        This kind of grid may be useful to initialize an array of structures.\r
+        </para>\r
+        <para>Following examples show how to use <varname>X, Y, Z</varname> in\r
+        most frequent applications.\r
+        </para> \r
+    </refsection>\r
+    <refsection role="examples">\r
+        <title>例</title>\r
+\r
+        <para><emphasis role="bold">Example #1:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[\r
+// Create a simple 2d grid\r
+x = linspace(-10,2,40);\r
+y = linspace(-5,5,40);\r
+[X,Y] = ndgrid(x,y);\r
+\r
+// Compute ordinates Z(X,Y) on the {X, Y} grid and plot Z(X,Y)\r
+Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+clf()\r
+plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image>\r
+        x = linspace(-10,2,40);\r
+        y = linspace(-5,5,40);\r
+        [X,Y] = ndgrid(x,y);\r
+        Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+        clf()\r
+        plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+        </scilab:image>\r
+\r
+        <para><emphasis role="bold">Example #2:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[\r
+// 簡単な3次元グリッドを作成\r
+nx = 10; ny = 6; nz = 4;\r
+x = linspace(0,2,nx);\r
+y = linspace(0,1,ny);\r
+z = linspace(0,0.5,nz);\r
+[X,Y,Z] = ndgrid(x,y,z);\r
+// 3次元グリッドを表示する ...\r
+XF=[]; YF=[]; ZF=[];\r
+for k=1:nz\r
+   [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+for j=1:ny\r
+   [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+                     matrix(Y(:,j,:),[nx,nz]),...\r
+                     matrix(Z(:,j,:),[nx,nz]));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+clf()\r
+plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+xtitle("A 3d grid !"); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image>\r
+            nx = 10; ny = 6; nz = 4;\r
+            x = linspace(0,2,nx);\r
+            y = linspace(0,1,ny);\r
+            z = linspace(0,0.5,nz);\r
+            [X,Y,Z] = ndgrid(x,y,z);\r
+            XF=[]; YF=[]; ZF=[];\r
+            for k=1:nz\r
+            [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            for j=1:ny\r
+            [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+            matrix(Y(:,j,:),[nx,nz]),...\r
+            matrix(Z(:,j,:),[nx,nz]));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+            xtitle("A 3d grid !");\r
+        </scilab:image>\r
+        <para><emphasis role="bold">Example #3: Create a table of digrams:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+[c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+c1+c2\r
+ ]]></programlisting>\r
+    <screen>\r
+<![CDATA[--> [c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+ c2  = \r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+\r
+ c1  = \r
+!a  a  a  a  a  a  a  a  !\r
+!b  b  b  b  b  b  b  b  !\r
+!c  c  c  c  c  c  c  c  !\r
+\r
+--> c1+c2\r
+ ans  =\r
+!aa  ab  ac  ad  ae  af  ag  ah  !\r
+!ba  bb  bc  bd  be  bf  bg  bh  !\r
+!ca  cb  cc  cd  ce  cf  cg  ch  !\r
+]]></screen>\r
+        </refsection>\r
+    <refsection role="see also">\r
+        <title>参照</title>\r
+        <simplelist type="inline">\r
+            <member>\r
+                <link linkend="meshgrid">meshgrid</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="kron">kron</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="feval">feval</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="eval3d">eval3d</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="nf3d">nf3d</link>\r
+            </member>\r
+        </simplelist>\r
+    </refsection>\r
+    <refsection role="history">\r
+        <title>履歴</title>\r
+        <revhistory>\r
+            <revision>\r
+                <revnumber>6.0</revnumber>\r
+                <revdescription>Extension to all homogeneous datatypes ([], booleans, encoded integers, polynomials, rationals, strings). Revision of the help page.\r
+                </revdescription>\r
+            </revision>\r
+        </revhistory>\r
+    </refsection>\r
+</refentry>
\ No newline at end of file
diff --git a/scilab/modules/elementary_functions/help/pt_BR/ndgrid.xml b/scilab/modules/elementary_functions/help/pt_BR/ndgrid.xml
new file mode 100644 (file)
index 0000000..8bbc340
--- /dev/null
@@ -0,0 +1,235 @@
+<?xml version="1.0" encoding="UTF-8"?>\r
+<refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:ns4="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="pt">\r
+    <refnamediv>\r
+        <refname>ndgrid</refname>\r
+        <refpurpose>constrói matrizes ou matrizes N-D, replicando alguns vetores dadas\r
+        </refpurpose>\r
+    </refnamediv>\r
+    <refsynopsisdiv>\r
+        <title>Seqüência de Chamamento</title>\r
+        <synopsis>[X, Y] = ndgrid(x,y)\r
+            [X, Y, Z] = ndgrid(x,y,z)\r
+            [X, Y, Z, T] = ndgrid(x,y,z,t)\r
+            [X1, X2, ..., Xm] = ndgrid(x1,x2,...,xm)\r
+        </synopsis>\r
+    </refsynopsisdiv>\r
+    <refsection role="arguments">\r
+        <title>Parâmetros</title>\r
+        <variablelist>\r
+            <varlistentry>\r
+                <term>x, y, z, ...</term>\r
+                <listitem>\r
+                    <para>vetores de quaisquer tipos de dados. \r
+                    Eles podem ter tipos de dados distintos.</para>\r
+                </listitem>\r
+            </varlistentry>\r
+            <varlistentry>\r
+                <term>X, Y, Z, ...</term>\r
+                <listitem>\r
+                    <para>matrizes, no caso de 2 argumentos de entrada, ou hipermatrizes\r
+                        em outro caso \r
+                    </para>\r
+                </listitem>\r
+            </varlistentry>\r
+        </variablelist>\r
+    </refsection>\r
+    <refsection role="description">\r
+        <title>Descrição</title>\r
+        <para>The first application of <function>ndgrid</function> is to build\r
+            a grid of nodes meshing the 2D or 3D or N-D space according to 2, 3,\r
+            or more sets\r
+            <literal>x</literal>, <literal> y</literal>, etc.. of  \r
+            "template" coordinates sampled along each direction/dimension of the\r
+            space that you want to mesh.\r
+        </para>\r
+        <para>Hence, the matrix or hypermatrix <literal>X</literal> is made\r
+            by replicating the vector <literal>x</literal> as all its columns ; \r
+            the matrix or hypermatrix <literal>Y</literal> is made\r
+            by replicating the vector <literal>y</literal> as all its rows ;\r
+            <literal>Z</literal> is made of replicating the vector \r
+            <literal>z</literal> along all its local thicknesses (3rd dimension); \r
+            etc\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
+ X  = \r
+   1.   1.   1.   1.\r
+   3.   3.   3.   3.\r
+   4.   4.   4.   4.\r
+\r
+   Y  = \r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+]]></screen>\r
+        <para>  \r
+            Then, the coordinates of the node(i,j) in the 2D space \r
+            will be\r
+            simply <literal>[x(i), y(j)]</literal> equal to \r
+            <literal>[X(i,j), Y(i,j)]</literal>. As well, the coordinates of a\r
+            <literal>node(i,j,k)</literal> of a 3D grid will be \r
+            <literal>[x(i), y(j), z(k)]</literal> equal to \r
+            <literal>[X(i,j,k), Y(i,j,k), Z(i,j,k)]</literal>.\r
+        </para>\r
+        <para>\r
+            This replication scheme can be generalized to any number of dimensions,\r
+            as well to any type of uniform data. Let's for instance consider 2\r
+            attributes:\r
+            <orderedlist>\r
+                <listitem>The first is a number, to be chosen from the vector say\r
+                <literal>n = [ 3 7 ]</literal>\r
+                </listitem>\r
+                <listitem>The second is a letter, to be chosen from the vector \r
+                say <literal>c = ["a" "e" "i" "o" "u" "y"]</literal>\r
+                </listitem>\r
+            </orderedlist>\r
+            Then we want to build the set of all {n,c} possible pairs. It will\r
+            just be the 2D grid:\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [N, C] = ndgrid([3 7],["a" "e" "i" "o" "u" "y"])\r
+ C  = \r
+!a  e  i  o  u  y  !\r
+!a  e  i  o  u  y  !\r
+\r
+ N  = \r
+   3.   3.   3.   3.   3.   3.\r
+   7.   7.   7.   7.   7.   7.\r
+]]></screen>\r
+        <para>Then, the object(i,j) will have the properties \r
+        <literal>{n(i) c(j)}</literal> that now can be addressed with\r
+        <literal>{N(i,j) C(i,j)}</literal>.\r
+        This kind of grid may be useful to initialize an array of structures.\r
+        </para>\r
+        <para>Following examples show how to use <varname>X, Y, Z</varname> in\r
+        most frequent applications.\r
+        </para> \r
+    </refsection>\r
+    <refsection role="examples">\r
+        <title>Exemplos </title>\r
+        \r
+        <para><emphasis role="bold">Example #1:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[ \r
+// Criando um grid 2d simples\r
+x = linspace(-10,2,40);\r
+y = linspace(-5,5,40);\r
+[X,Y] = ndgrid(x,y);\r
+\r
+// Compute ordinates Z(X,Y) on the {X, Y} grid and plot Z(X,Y)\r
+Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+clf()\r
+plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image>\r
+        x = linspace(-10,2,40);\r
+        y = linspace(-5,5,40);\r
+        [X,Y] = ndgrid(x,y);\r
+        Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+        clf()\r
+        plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+        </scilab:image>\r
+        \r
+        <para><emphasis role="bold">Example #2:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[ \r
+// criando um grid 3d simples\r
+nx = 10; ny = 6; nz = 4;\r
+x = linspace(0,2,nx);\r
+y = linspace(0,1,ny);\r
+z = linspace(0,0.5,nz);\r
+[X,Y,Z] = ndgrid(x,y,z);\r
+// tente exibir este grid 3d...\r
+XF=[]; YF=[]; ZF=[];\r
+for k=1:nz\r
+   [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+for j=1:ny\r
+   [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+                     matrix(Y(:,j,:),[nx,nz]),...\r
+                     matrix(Z(:,j,:),[nx,nz]));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
+clf()\r
+plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+xtitle("A 3d grid !"); show_window()\r
+ ]]>    </programlisting>\r
+        <scilab:image>\r
+            nx = 10; ny = 6; nz = 4;\r
+            x = linspace(0,2,nx);\r
+            y = linspace(0,1,ny);\r
+            z = linspace(0,0.5,nz);\r
+            [X,Y,Z] = ndgrid(x,y,z);\r
+            \r
+            XF=[]; YF=[]; ZF=[];\r
+            \r
+            for k=1:nz\r
+            [xf,yf,zf] = nf3d(X(:,:,k),Y(:,:,k),Z(:,:,k));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            \r
+            for j=1:ny\r
+            [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),...\r
+            matrix(Y(:,j,:),[nx,nz]),...\r
+            matrix(Z(:,j,:),[nx,nz]));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+            xtitle("A 3d grid !"); \r
+        </scilab:image>\r
+\r
+        <para><emphasis role="bold">Example #3: Create a table of digrams:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+[c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+c1+c2\r
+ ]]>    </programlisting>\r
+        <screen>\r
+<![CDATA[--> [c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+ c2  = \r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+\r
+ c1  = \r
+!a  a  a  a  a  a  a  a  !\r
+!b  b  b  b  b  b  b  b  !\r
+!c  c  c  c  c  c  c  c  !\r
+\r
+--> c1+c2\r
+ ans  =\r
+!aa  ab  ac  ad  ae  af  ag  ah  !\r
+!ba  bb  bc  bd  be  bf  bg  bh  !\r
+!ca  cb  cc  cd  ce  cf  cg  ch  !\r
+]]></screen>\r
+\r
+        </refsection>\r
+    <refsection role="see also">\r
+        <title>Ver Também</title>\r
+        <simplelist type="inline">\r
+            <member>\r
+                <link linkend="meshgrid">meshgrid</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="kron">kron</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="feval">feval</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="eval3d">eval3d</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="nf3d">nf3d</link>\r
+            </member>\r
+        </simplelist>\r
+    </refsection>\r
+    <refsection role="history">\r
+        <title>Histórico</title>\r
+        <revhistory>\r
+            <revision>\r
+                <revnumber>6.0</revnumber>\r
+                <revdescription>Extension to all homogeneous datatypes ([], booleans, encoded integers, polynomials, rationals, strings). Revision of the help page.\r
+                </revdescription>\r
+            </revision>\r
+        </revhistory>\r
+    </refsection>\r
+</refentry>\r
diff --git a/scilab/modules/elementary_functions/help/ru_RU/ndgrid.xml b/scilab/modules/elementary_functions/help/ru_RU/ndgrid.xml
new file mode 100644 (file)
index 0000000..f8322e7
--- /dev/null
@@ -0,0 +1,233 @@
+<?xml version="1.0" encoding="UTF-8"?>\r
+<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="ru">\r
+    <refnamediv>\r
+        <refname>ndgrid</refname>\r
+        <refpurpose>строит матриц или N-мерные массивы путем репликации данных векторов\r
+        </refpurpose>\r
+    </refnamediv>\r
+    <refsynopsisdiv>\r
+        <title>Последовательность вызова</title>\r
+        <synopsis>\r
+            X, Y] = ndgrid(x,y)\r
+            [X, Y, Z] = ndgrid(x,y,z)\r
+            [X, Y, Z, T] = ndgrid(x,y,z,t)\r
+            [X1, X2, ..., Xm] = ndgrid(x1,x2,...,xm)\r
+        </synopsis>\r
+    </refsynopsisdiv>\r
+    <refsection role="arguments">\r
+        <title>Аргументы</title>\r
+        <variablelist>\r
+            <varlistentry>\r
+                <term>x, y, z, ...</term>\r
+                <listitem>\r
+                    <para>векторы любых типов данных. Они могут иметь различные типы данных.</para>\r
+                </listitem>\r
+            </varlistentry>\r
+            <varlistentry>\r
+                <term>X, Y, Z, ...</term>\r
+                <listitem>\r
+                    <para>\r
+                        в случае двух входных аргументов - матрицы, в противном случае - гиперматрицы\r
+                    </para>\r
+                </listitem>\r
+            </varlistentry>\r
+        </variablelist>\r
+    </refsection>\r
+    <refsection role="description">\r
+        <title>Описание</title>\r
+        <para>The first application of <function>ndgrid</function> is to build\r
+            a grid of nodes meshing the 2D or 3D or N-D space according to 2, 3,\r
+            or more sets\r
+            <literal>x</literal>, <literal> y</literal>, etc.. of  \r
+            "template" coordinates sampled along each direction/dimension of the\r
+            space that you want to mesh.\r
+        </para>\r
+        <para>Hence, the matrix or hypermatrix <literal>X</literal> is made\r
+            by replicating the vector <literal>x</literal> as all its columns ; \r
+            the matrix or hypermatrix <literal>Y</literal> is made\r
+            by replicating the vector <literal>y</literal> as all its rows ;\r
+            <literal>Z</literal> is made of replicating the vector \r
+            <literal>z</literal> along all its local thicknesses (3rd dimension); \r
+            etc\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [X, Y] = ndgrid([1 3 4], [0 2 4 6])\r
+ X  = \r
+   1.   1.   1.   1.\r
+   3.   3.   3.   3.\r
+   4.   4.   4.   4.\r
+\r
+   Y  = \r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+   0.   2.   4.   6.\r
+]]></screen>\r
+        <para>\r
+            This replication scheme can be generalized to any number of dimensions,\r
+            as well to any type of uniform data. Let's for instance consider 2\r
+            attributes:\r
+            <orderedlist>\r
+                <listitem>The first is a number, to be chosen from the vector say\r
+                <literal>n = [ 3 7 ]</literal>\r
+                </listitem>\r
+                <listitem>The second is a letter, to be chosen from the vector \r
+                say <literal>c = ["a" "e" "i" "o" "u" "y"]</literal>\r
+                </listitem>\r
+            </orderedlist>\r
+            Then we want to build the set of all {n,c} possible pairs. It will\r
+            just be the 2D grid:\r
+        </para>\r
+        <screen>\r
+<![CDATA[--> [N, C] = ndgrid([3 7],["a" "e" "i" "o" "u" "y"])\r
+ C  = \r
+!a  e  i  o  u  y  !\r
+!a  e  i  o  u  y  !\r
+\r
+ N  = \r
+   3.   3.   3.   3.   3.   3.\r
+   7.   7.   7.   7.   7.   7.\r
+]]></screen>\r
+        <para>Then, the object(i,j) will have the properties \r
+        <literal>{n(i) c(j)}</literal> that now can be addressed with\r
+        <literal>{N(i,j) C(i,j)}</literal>.\r
+        This kind of grid may be useful to initialize an array of structures.\r
+        </para>\r
+        <para>Following examples show how to use <varname>X, Y, Z</varname> in\r
+        most frequent applications.\r
+        </para> \r
+    </refsection>\r
+    <refsection role="examples">\r
+        <title>Примеры</title>\r
+\r
+        <para><emphasis role="bold">Example #1:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+// создание простой двухмерной координатной сетки\r
+x = linspace(-10,2,40);\r
+y = linspace(-5,5,40);\r
+[X,Y] = ndgrid(x,y);\r
+\r
+// Compute ordinates Z(X,Y) on the {X, Y} grid and plot Z(X,Y)\r
+Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+clf()\r
+plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+ ]]>    </programlisting>\r
+        <scilab:image>\r
+        x = linspace(-10,2,40);\r
+        y = linspace(-5,5,40);\r
+        [X,Y] = ndgrid(x,y);\r
+        Z = X - 3*X.*sin(X).*cos(Y-4) ;\r
+        clf()\r
+        plot3d(x,y,Z, flag=[color("green") 2 4], alpha=7, theta=60); show_window()\r
+        </scilab:image>\r
+\r
+        <para><emphasis role="bold">Example #2:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+// создание простой трёхмерной координатной сетки\r
+nx = 10; ny = 6; nz = 4;\r
+x = linspace(0,2,nx);\r
+y = linspace(0,1,ny);\r
+z = linspace(0,0.5,nz);\r
+[X,Y,Z] = ndgrid(x,y,z);\r
\r
+// попытаемся отобразить эту трёхмерную координатную сетку ...\r
+XF=[]; YF=[]; ZF=[];\r
\r
+for k=1:nz\r
+   [xf,yf,zf] = nf3d(X(:,:,k), Y(:,:,k), Z(:,:,k));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
\r
+for j=1:ny\r
+   [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),..\r
+                     matrix(Y(:,j,:),[nx,nz]),..\r
+                     matrix(Z(:,j,:),[nx,nz]));\r
+   XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+end\r
\r
+clf()\r
+plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+xtitle("Трёхмерная сетка!"); show_window()\r
+ ]]></programlisting>\r
+        <scilab:image localized="true">\r
+            nx = 10; ny = 6; nz = 4;\r
+            x = linspace(0,2,nx);\r
+            y = linspace(0,1,ny);\r
+            z = linspace(0,0.5,nz);\r
+            [X,Y,Z] = ndgrid(x,y,z);\r
+            \r
+            XF=[]; YF=[]; ZF=[];\r
+            \r
+            for k=1:nz\r
+            [xf,yf,zf] = nf3d(X(:,:,k), Y(:,:,k), Z(:,:,k));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            \r
+            for j=1:ny\r
+            [xf,yf,zf] = nf3d(matrix(X(:,j,:),[nx,nz]),..\r
+            matrix(Y(:,j,:),[nx,nz]),..\r
+            matrix(Z(:,j,:),[nx,nz]));\r
+            XF = [XF xf]; YF = [YF yf]; ZF = [ZF zf];\r
+            end\r
+            \r
+            clf()\r
+            plot3d(XF,YF,ZF, flag=[0 6 3], 66, 61, leg="X@Y@Z")\r
+            xtitle("Трёхмерная сетка!"); show_window()\r
+            \r
+        </scilab:image>\r
+        \r
+        <para><emphasis role="bold">Example #3: Create a table of digrams:</emphasis> </para>\r
+        <programlisting role="example"><![CDATA[  \r
+[c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+c1+c2\r
+ ]]>    </programlisting>\r
+        <screen>\r
+<![CDATA[--> [c1, c2] = ndgrid(["a" "b" "c"], ["a" "b" "c" "d" "e" "f" "g" "h"])\r
+ c2  = \r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+!a  b  c  d  e  f  g  h  !\r
+\r
+ c1  = \r
+!a  a  a  a  a  a  a  a  !\r
+!b  b  b  b  b  b  b  b  !\r
+!c  c  c  c  c  c  c  c  !\r
+\r
+--> c1+c2\r
+ ans  =\r
+!aa  ab  ac  ad  ae  af  ag  ah  !\r
+!ba  bb  bc  bd  be  bf  bg  bh  !\r
+!ca  cb  cc  cd  ce  cf  cg  ch  !\r
+]]></screen>\r
+        \r
+    </refsection>\r
+    <refsection role="see also">\r
+        <title>Смотрите также</title>\r
+        <simplelist type="inline">\r
+            <member>\r
+                <link linkend="meshgrid">meshgrid</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="kron">kron</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="feval">feval</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="eval3d">eval3d</link>\r
+            </member>\r
+            <member>\r
+                <link linkend="nf3d">nf3d</link>\r
+            </member>\r
+        </simplelist>\r
+    </refsection>\r
+    <refsection role="history">\r
+        <title>История</title>\r
+        <revhistory>\r
+            <revision>\r
+                <revnumber>6.0</revnumber>\r
+                <revdescription>Extension to all homogeneous datatypes ([], booleans, encoded integers, polynomials, rationals, strings). Revision of the help page.\r
+                </revdescription>\r
+            </revision>\r
+        </revhistory>\r
+    </refsection>\r
+</refentry>\r
index 5120739..c0f4383 100644 (file)
@@ -1,6 +1,6 @@
 // Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 // Copyright (C) Bruno Pincon
-//
+// Copyright (C) 2015 - Samuel GOUGEON
 // Copyright (C) 2012 - 2016 - Scilab Enterprises
 //
 // This file is hereby licensed under the terms of the GNU GPL v2.0,
 // along with this program.
 
 function [varargout] = ndgrid(varargin)
-    //
-    //  CALLING SEQUENCES
-    //       [X, Y] = ndgrid(x, y)
-    //    or [X, Y, Z] = ndgrid(x, y, z)
-    //    or [X, Y, Z, T] = ndgrid(x, y, z, t)
-    //    etc ...
-    //
-    //  PURPOSE
-    //     An utility similar to the Matlab 's one. For instance
-    //     in the 3d case :
-    //
-    //     [X, Y, Z] = ndgrid(x, y, z)
-    //
-    //     with x, y, z three vectors of length nx, ny, nz, we have
-    //     X, Y, Z which are hypermatrices of format nx x ny x nz
-    //     and, forall  i in [1,nx], j in [1, ny], k in [1, nz]
-    //         X(i,j,k) = x(i)
-    //         Y(i,j,k) = y(j)
-    //         Z(i,j,k) = z(k)
-    //
-    //     X, Y, Z are the coordinates of the grid points formed by
-    //     the cartesian product of the one dimensional grids
-    //     x, y and z.
-    //
-    //  AUTHOR
-    //     Bruno Pincon <Bruno.Pincon@iecn.u-nancy.fr>
-    //
     nbdim = length(varargin)
     if nbdim < 2 then
-        error(msprintf(gettext("%s: Wrong number of input arguments: At least %d expected.\n"),"ndgrid",2));
+        msg = _("%s: Wrong number of input arguments: At least %d expected.\n")
+        error(msprintf(msg, "ndgrid", 2))
     end
+
     dim = zeros(1,nbdim)
     for k = 1:nbdim
-        if type(varargin(k)) ~= 1 then
-            error(msprintf(gettext("%s: Wrong type for argument #%d: Real expected.\n"),"ndgrid",k));
+        if and(type(varargin(k)) ~= [1 2 4 8 10]) & typeof(varargin(k))~="rational"
+            msg = _("%s: Wrong type for argument #%d: Booleans, Integers, Decimals, Complexes, Polynomials, Rationals or Texts expected.\n")
+            error(msprintf(msg, "ndgrid", k))
         end
-        dim(k) = length(varargin(k))
-        varargin(k) = matrix(varargin(k),1,dim(k)) // force row form
+        dim(k) = size(varargin(k),"*")
+        varargin(k) = matrix(varargin(k),1,-1) // force row form
     end
 
     varargout = list()
+    // Manage input []
+    for v = varargin
+        if v==[]
+            for i=1:nbdim
+                varargout(i) = []
+            end
+            return
+        end
+    end
+
+    // Processing:
     for k = 1:nbdim
-        varargout(k) = matrix(     ones(1,prod(dim(k+1:$))) ...
-        .*. varargin(k)              ...
-        .*. ones(1,prod(dim(1:k-1))) , dim )
+        tmp = varargin(k)
+        ind = ones(1,prod(dim(k+1:$))) .*. (1:size(tmp,"*")) ..
+        .*. ones(1,prod(dim(1:k-1)))
+        if typeof(tmp)~="rational"
+            varargout(k) = matrix( tmp(ind) , dim )
+        else
+            varargout(k) = rlist(matrix(tmp(2)(ind), dim), matrix(tmp(3)(ind), dim), [])
+        end
     end
 endfunction