<?xml version="1.0" encoding="UTF-8"?>
<!--
 * Scilab ( https://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) INRIA - Fabrice Leray
 * Copyright (C) 2012 - 2016 - Scilab Enterprises
 * Copyright (C) 2018 - 2020 - Samuel GOUGEON
 *
 * This file is hereby licensed under the terms of the GNU GPL v2.0,
 * pursuant to article 5.3.4 of the CeCILL v.2.1.
 * This file was originally licensed under the terms of the CeCILL v2.1,
 * and continues to be available under such terms.
 * For more information, see the COPYING file which you should have received
 * along with this program.
 *
 -->
<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="plot" xml:lang="pt">
    <refnamediv>
        <refname>plot</refname>
        <refpurpose>Esboço 2d</refpurpose>
    </refnamediv>
    <refsynopsisdiv>
        <title>Seqüência de Chamamento</title>
        <synopsis>
            plot     // demo
            plot(y)
            plot(x, y)
            plot(x, func)
            plot(x, list(func, params))
            plot(x, polynomial)
            plot(x, rational)
            plot(.., LineSpec)
            plot(.., LineSpec, GlobalProperty)
            plot(x1, y1, LineSpec1, x2,y2,LineSpec2,...xN, yN, LineSpecN, GlobalProperty1,.. GlobalPropertyM)
            plot(x1,func1,LineSpec1, x2,y2,LineSpec2,...xN,funcN,LineSpecN, GlobalProperty1, ..GlobalPropertyM)
            plot(logflag,...)
            plot(axes_handle,...)
        </synopsis>
    </refsynopsisdiv>
    <refsection role="parameters">
        <title>Parâmetros</title>
        <variablelist>
            <varlistentry>
                <term>x</term>
                <listitem>
                    <para>uma matriz ou vetor de reais. Se omitido, é assumido como
                        sendo o vetor <literal>1:n</literal> onde <literal>n</literal> é o
                        número de pontos de curva dado pelo parâmetro
                        <literal>y</literal>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>y</term>
                <listitem>
                    um vetor ou matriz de reais.
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>func</term>
                <listitem>
                    <para>
                        função definida como um macro ou uma primitiva, como em
                        <literal>plot(x, sin)</literal>.
                        If the function to plot needs some parameters as input arguments, the
                        function and its parameters can be specified through a list, as in
                        <literal>plot(x, list(delip,-0.4))</literal>
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>polynomial</term>
                <listitem>
                    Single polynomial or array of polynomials.
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>rational</term>
                <listitem>
                    Single rational or array of rationals.
                    <para/>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>y1, y2, y3,..</term>
                <listitem>
                    <para>
                        Can be any of the possible input types described above:
                        <itemizedlist>
                            <listitem>
                                vectors or matrices of real numbers or of integers
                            </listitem>
                            <listitem>
                                handle of a function (possibly in a list with its parameters).
                            </listitem>
                            <listitem>
                                polynomials
                            </listitem>
                            <listitem>
                                rationals
                            </listitem>
                        </itemizedlist>
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>LineSpec</term>
                <listitem>
                    <para>este argumento opcional deve ser usado como um atalho para
                        especificar um modo de desenhar uma linha. Podemos ter um
                        <literal>LineSpec</literal> por<literal> y</literal> ou
                        <literal>{x,y}</literal> previamente entrados. As opções
                        <literal>LineSpec</literal> lidam com os especificadores LineStyle,
                        Marker e Color (ver <link linkend="LineSpec">LineSpec</link>). Estes
                        especificadores determinam o estilo de linha, de marcas e a cor das
                        linhas esboçadas.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>GlobalProperty</term>
                <listitem>
                    <para>este argumento opcional representa uma seqüência de pares de
                        declarações <literal>{PropertyName,PropertyValue}</literal> tque
                        define propriedades globais de objetos a serem aplicadas a todas as
                        curvas criadas pelo esboço. Para uma visualização completa de das
                        propriedades disponíveis veja <link linkend="GlobalProperty">GlobalProperty</link>.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>logflag</term>
                <listitem>
                    <para>
                        "ln" | "nl" | "ll" : 2-character word made of "l" standing for
                        "<emphasis role="bold">L</emphasis>ogarithmic" or/and "n" standing for
                        "<emphasis role="bold">N</emphasis>ormal". The first character applies to
                        the X axis, the second to the Y axis. Hence, "ln" means that the X axis
                        is logarithmic and the Y axis is normal. The default is "nn":
                        both axes in normal scales.
                    </para>
                    <para>
                        <literal>logflag</literal> must be used after <literal>axes_handle</literal>
                        (if any) and before the first curve's data <literal>x</literal> or
                        <literal>y</literal> or <literal>func</literal>.
                        It applies to all curves drawn by the <literal>plot(…)</literal> instruction.
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>axes_handle</term>
                <listitem>
                    <para>este argumento opcional força o esboço a aparecer dentro dos
                        eixos selecionados fornecidos por <literal>axes_handle</literal> ao
                        invés dos eixos correntes (ver <link linkend="gca">gca</link>).
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection role="description">
        <title>Descrição</title>
        <para>
            <literal>plot</literal> esboça um conjunto de curvas 2d.
            <literal>plot</literal> foi reconstruído para lidar melhor com a sintaxe
            do Matlab. Para melhorar a compatibilidade gráfica com o Matlab, utilize
            <literal>plot</literal> (ao invés de <link linkend="plot2d">plot2d</link>).
        </para>
        <para>Especificação de entrada de dados:</para>
        <para>Neste parágrafo, para sermos mais claros, não mencionaremos os
            argumentos opcionais <literal>LineSpec</literal> ou
            <literal>GlobalProperty</literal> já que eles não interferem na entrada de
            dados (exceto pelas propriedades <literal>"Xdata"</literal>,
            <literal>"Ydata"</literal> e <literal>"Zdata"</literal>,
            ver <link linkend="GlobalProperty">GlobalProperty</link>). É assumido que todos
            estes argumentos podem estar presentes também.
        </para>
        <para>
            Se <literal>y</literal> é um vetor, plot(y) esboça um vetor
            <literal>y</literal> versus o vetor
            <literal>1:size(y,'*')</literal>.
        </para>
        <para>
            Se <literal>y</literal> é uma matriz, plot(y) esboça cada coluna de
            <literal>y</literal> versus o vetor <literal>1:size(y,1)</literal>.
        </para>
        <para>
            Se <literal>x</literal> e <literal>y</literal> são vetores,
            plot(x,y) esboça o vetor <literal>y</literal> versus o vetor
            <literal>x</literal>. Os vetores <literal>x</literal> e
            <literal>y</literal> devem ter o mesmo número de entradas.
        </para>
        <para>
            Se <literal>x</literal> é um vetor e <literal>y</literal> uma matriz
            plot(x,y) esboça cada coluna de <literal>y</literal> versus o vetor
            <literal>x</literal>. Neste caso, o número de colunas de
            <literal>y</literal> deve ser igual ao número de entradas de
            <literal>x</literal>.
        </para>
        <para>
            Se <literal>x</literal> e <literal>y</literal> são matrizes,
            plot(x,y) esboça cada coluna de <literal>y</literal> versus a coluna
            correspondente de <literal>x</literal>. Neste caso, os tamanhos
            <literal>x</literal> e <literal>y</literal> devem ser os mesmos.
        </para>
        <para>
            Finalmente, se apenas <literal>x</literal> ou <literal>y</literal> é
            uma matriz, o vetor é esboçado versus cada linha ou cada coluna da matriz.
            A escolha é feita dependendo se a dimensão de linha ou coluna do vetor
            coincide com a dimensão de linha ou coluna da matriz. No caso de uma
            matriz quadrada (apenas <literal>x</literal> ou penas
            <literal>y</literal>), a prioridade é dada a colunas ao invés de linhas
            (ver exemplos abaixo).
        </para>
        <para>
            <literal>y</literal> também pode ser uma função definida como um
            macro ou uma primitiva. Neste caso, os dados <literal>x</literal> devem
            ser fornecidos (como um vetor ou uma matriz) e a computação correspondente
            de <literal>y(x)</literal> é feita implicitamente.
        </para>
        <para>
            Os argumentos <literal>LineSpec</literal> e
            <literal>GlobalProperty</literal> devem ser utilizados para customizar o
            esboço. Aqui está uma lista completa das opções disponíveis.
        </para>
        <variablelist>
            <varlistentry>
                <term>LineSpec</term>
                <listitem>
                    <para>esta opção pode ser utilizada para se especificar, de um modo
                        curto e fácil, como as curvas são desenhadas. Deve sempre ser um
                        string contendo referências aos especificadores LineStyle, Marker e
                        Color.
                    </para>
                    <para>Essas referências devem ser ajustadas denro do string (a ordem
                        não é importante) de modo a não ter ambigüidades. Por exemplo, para
                        especificar uma linha vermelha de traço longo com marcas de rombos,
                        pode-se escrever : <literal>'r--d'</literal> ou
                        <literal>'--dire'</literal> ou <literal>'--reddiam'</literal> ou
                        outra sentença sem ambigüidade... ou de modo completo
                        <literal>'diamondred--'</literal> (ver <link linkend="LineSpec">LineSpec</link>).
                    </para>
                    <para>Note que os estilos de linha e marcas (e tamanhos) e as cores,
                        podem ser (re*)ajustados através das propriedades da entidade
                        poligonal (ver <link linkend="polyline_properties">polyline_properties</link>).
                    </para>
                </listitem>
            </varlistentry>
            <varlistentry>
                <term>GlobalProperty</term>
                <listitem>
                    <para>esta opção pode ser utilizada para especificar como as linhas
                        serão desenhadas com mais opções que via
                        <literal>LineSpec</literal>. Deve sempre ser um par de declarações
                        constituidos de um string definindo <literal>PropertyName</literal>,
                        (nome da propriedade) e seu valor associado
                        <literal>PropertyValue</literal> (que pode ser um string, um inteiro
                        ou qualquer outra coisa... dependendo do tipo de
                        <literal>PropertyName</literal>). Utilizando-se
                        <literal>GlobalProperty</literal>, pode-se ajustar várias
                        propriedades : todas as propriedades disponíveis via LineSpec e
                        mais: a cor da marca (plano de fundo e primeiro plano), a
                        visibilidade, o recorte e a espessura das curvas.
                        (ver <link linkend="GlobalProperty">GlobalProperty</link>)
                    </para>
                    <para>
                        Note que todas as propriedades podem ser (re-)ajustadas
                        através das propriedades de entidades poligonais
                        (ver <link linkend="polyline_properties">polyline_properties</link>).
                    </para>
                </listitem>
            </varlistentry>
        </variablelist>
    </refsection>
    <refsection role="description">
        <title>Observações </title>
        <para>Por padrão, esboços sucessivos são superpostos. Para limpar o esboço
            anterior, use <literal>clf()</literal>. Para habilitar o modo
            <literal>auto_clear</literal> (limpeza automática) como modo padrão, edite
            seus eixos fazendo o seguinte:
        </para>
        <para>da=gda();</para>
        <para>da.auto_clear = 'on'</para>
        <para>
            Para uma melhor exibição, a função <literal>plot</literal> pode
            modificar a propriedade <literal>box</literal> de seu Axes (eixos) raíze.
            Isto acontece quando uma entidade Axes é criada por uma chamada a
            <literal>plot</literal> ou é vazia antes da chamada. Se um dos eixos é
            centrado na origem, box é desabilitado. Em caso contrário, box é
            habilitado.
        </para>
        <para>Para mais informações sobre a propriedade box e sobre o
            posicionamento dos eixos, veja <link linkend="axes_properties">axes_properties</link>
        </para>
        <para>Uma tabela de cores padrão é utilizada para colorir as curvas
            esboçadas quando você não especifica as cores. Ao desenhar linhas
            múltiplas, o comando plot automaticamente atribui as cores abaixo de modo
            cíclico. Aqui estão as cores utilizadas:
        </para>
        <informaltable border="1">
            <tr>
                <th> <literal>R</literal> </th>
                <th> <literal>G</literal> </th>
                <th> <literal>B</literal> </th>
            </tr>
            <tr> <td>0.</td>   <td>0.</td>   <td>1.</td>   </tr>
            <tr> <td>0.</td>   <td>0.5</td>  <td>0.</td>   </tr>
            <tr> <td>1.</td>   <td>0.</td>   <td>0.</td>   </tr>
            <tr> <td>0.</td>   <td>0.75</td> <td>0.75</td> </tr>
            <tr> <td>0.75</td> <td>0.</td>   <td>0.75</td> </tr>
            <tr> <td>0.75</td> <td>0.75</td> <td>0.</td>   </tr>
            <tr> <td>0.25</td> <td>0.25</td> <td>0.25</td> </tr>
        </informaltable>
        <para/>
        <para>
            Entre com o comando <literal>plot</literal> para visualizar uma
            demonstração.
        </para>
    </refsection>
    <refsection role="examples">
        <title>Exemplos</title>
        <para>
            <emphasis role="bold">Choosing the normal or logarithmic plotting mode:</emphasis>
        </para>
        <programlisting role="example"><![CDATA[
gda().grid = [1 1]*color("grey70");
title(gda(), "fontsize", 3, "color", "lightseagreen", "fontname", "helvetica bold");

x = linspace(1e-1,100,1000);
xm = 35;
dx = 17;
G = exp(-((x-xm)/dx).^2/2)*30;

scf(1); clf
subplot(2,2,1), plot(x, G),       title("plot(x, y)")
subplot(2,2,2), plot("ln", x, G), title("semilog-x : plot(""ln"", x, y)"); gca().sub_ticks(1) = 8;
subplot(2,2,3), plot("nl", x, G), title("semilog-y : plot(""nl"", x, y)"); gca().sub_ticks(2) = 8;
subplot(2,2,4), plot("ll", x, G), title("loglog : plot(""ll"", x, y)");    gca().sub_ticks = [8 8];

sda();
 ]]></programlisting>
        <scilab:image>
            gda().grid = [1 1]*color("grey70");
            title(gda(), "", "fontsize", 3, "color", "lightseagreen", "fontname", "helvetica bold");

            x = linspace(1e-1,100,1000);
            xm = 35;
            dx = 17;
            G = exp(-((x-xm)/dx).^2/2)*30;
            scf(1); clf
            subplot(2,2,1), plot(x, G),       title("plot(x, y)")
            subplot(2,2,2), plot("ln", x, G), title("semilog-x : plot(""ln"", x, y)")
            gca().sub_ticks(1) = 8;
            subplot(2,2,3), plot("nl", x, G), title("semilog-y : plot(""nl"", x, y)")
            gca().sub_ticks(2) = 8;
            subplot(2,2,4), plot("ll", x, G), title("loglog : plot(""ll"", x, y)")
            gca().sub_ticks = [8 8];

            gcf().axes_size = [750 520];
            sda();
        </scilab:image>
        <para/>
        <para>
            <emphasis role="bold">Simple plot of a single curve:</emphasis>
        </para>
        <programlisting role="example"><![CDATA[
// Default abscissae = indices
subplot(1,2,1)
plot(sin(0:0.1:2*%pi))
xlabel("x indices")

// With explicit abscissae:
x = [0:0.1:2*%pi]';
subplot(1,2,2)
plot(x, sin(x))
xlabel("Specified abscissae")
 ]]></programlisting>
        <scilab:image>
            // Default abscissae = indices
            subplot(1,2,1)
            plot(sin(0:0.1:2*%pi))
            xlabel("x indices")

            // With explicit abscissae:
            x = [0:0.1:2*%pi]';
            subplot(1,2,2)
            plot(x, sin(x))
            xlabel("Specified abscissae")

            gcf().axes_size = [700 350];
        </scilab:image>
        <para>
            <emphasis role="bold">Multiple curves with shared abscissae:</emphasis>
            Y: 1 column = 1 curve:
        </para>
        <programlisting role="example"><![CDATA[
clf
x = [0:0.1:2*%pi]';
plot(x, [sin(x) sin(2*x) sin(3*x)])
 ]]></programlisting>
        <scilab:image>
            x=[0:0.1:2*%pi]';
            plot(x,[sin(x) sin(2*x) sin(3*x)])

            gcf().axes_size = [700 350];
        </scilab:image>
        <para>
            <emphasis role="bold">
                Specifying a macro or a builtin instead of explicit ordinates:
            </emphasis>
        </para>
        <para>
        <programlisting role="example"><![CDATA[
clf
subplot(2,2,1)         // sin() is a builtin
plot(1:0.1:10, sin)    // <=> plot(1:0.1:10, sin(1:0.1:10))
title("plot(x, sin)", "fontsize",3)

// with a macro:
deff('y = myFun(x)','y = x + rand(x)')
subplot(2,2,2)
plot(-3:0.1:5, myFun)
title("plot(x, myFun)", "fontsize",3)

// With functions with parameters:
subplot(2,2,3)
plot(1:0.05:7, list(delip, -0.4))  // <=> plot(1:0.05:7, delip(1:0.05:7,-0.4) )
title("plot(x, list(delip,-0.4))", "fontsize",3)

function Y = myPow(x,p)
    [X,P] = ndgrid(x,p);
    Y = X.^P;
    m = max(abs(Y),"r");
    for i = 1:size(Y,2)
        Y(:,i) = Y(:,i)/m(i);
    end
endfunction
x = -5:0.1:6;
subplot(2,2,4)
plot(x, list(myPow,1:5))
title("plot(x, list(myPow,1:5))", "fontsize",3)
 ]]></programlisting>
        <scilab:image><![CDATA[
            subplot(2,2,1)         // sin() is a builtin
            plot(1:0.1:10, sin)    // <=> plot(1:0.1:10, sin(1:0.1:10))
            title("plot(x,sin)", "fontsize",3)

            // with a macro:
            deff('y = myFun(x)','y = x + rand(x)')
            subplot(2,2,2)
            plot(-3:0.1:5, myFun)
            title("plot(x, myFun)", "fontsize",3)

            // With functions with parameters:
            subplot(2,2,3)
            plot(1:0.05:7, list(delip, -0.4))  // <=> plot(1:0.05:7, delip(1:0.05:7,-0.4) )
            title("plot(x, list(delip,-0.4))", "fontsize",3)

            function Y = myPow(x,p)
                [X,P] = ndgrid(x,p);
                Y = X.^P;
                m = max(abs(Y),"r");
                for i = 1:size(Y,2)
                    Y(:,i) = Y(:,i)/m(i);
                end
            endfunction
            x = -5:0.1:6;
            subplot(2,2,4)
            plot(x, list(myPow,1:5))
            title("plot(x, list(myPow,1:5))", "fontsize",3)

            gcf().axes_size = [730 500];
        ]]></scilab:image>
        </para>
        <para/>
        <para>
            <emphasis role="bold">
                Plotting the graph of polynomials or rationals:
            </emphasis>
        </para>
        <para>
        <programlisting role="example"><![CDATA[
clf
s = %s;

// Polynomials
x = -0.5:0.02:3;
p = s*[2 ; (s-2) ; (s-1)*(s-2)]
subplot(1,2,1)
plot(x, p)
legend(prettyprint(p,"latex","",%t), 2);

// Rationals
x = -0.5:0.02:2;
r = (s-1)*s/(s-7)./[s+1, s-4]
subplot(1,2,2)
plot(x, r)
legend(prettyprint(r,"latex","",%t), 2);

gcf().children.grid = color("grey70")*[1 1]; // grids
gcf().children.children([1 3]).font_size=3;  // legends
 ]]></programlisting>
        <screen><![CDATA[
--> p = s*[2 ; (s-2) ; (s-1)*(s-2)]
 p  =
  2s
  -2s +s²
  2s -3s² +s³

../..
--> r = (s-1)*s/(s-7)./[s+1, s-4]
 r  =
     -s +s²      -s +s²
   ----------  -----------
   -7 -6s +s²  28 -11s +s²
]]></screen>
        <scilab:image><![CDATA[
            s = %s;

            // Polynomials
            x = -0.5:0.02:3;
            p = s*[2 ; (s-2) ; (s-1)*(s-2)]
            subplot(1,2,1)
            plot(x, p)
            legend(prettyprint(p,"latex","",%t), 2);

            // Rationals
            x = -0.5:0.02:2;
            r = (s-1)*s/(s-7)./[s+1, s-4]
            subplot(1,2,2)
            plot(x, r)
            legend(prettyprint(r,"latex","",%t), 2);

            gcf().children.grid = color("grey70")*[1 1]; // grids
            gcf().children.children([1 3]).font_size=3;  // legends
            gcf().axes_size = [650 400];
        ]]></scilab:image>
        </para>
        <para/>
        <para>
            <emphasis role="bold">Setting curves simple styles when calling plot():</emphasis>
        </para>
        <programlisting role="example"><![CDATA[
clf
t = -%pi:%pi/20:2*%pi;
// sin() : in Red, with O marks, without line
// cos() : in Green, with + marks, with a solid line
// gaussian: in Blue, without marks, with dotted line
gauss = 1.5*exp(-(t/2-1).^2)-1;

plot(t,sin,'ro', t,cos,'g+-', t,gauss,':b')
 ]]></programlisting>
        <scilab:image><![CDATA[
            t = -%pi:%pi/20:2*%pi;
            // sin() : in Red, with O marks, without line
            // cos() : in Green, with + marks, with a solid line
            // gaussian: in Blue, without marks, with dotted line
            gauss = 1.5*exp(-(t/2-1).^2)-1;

            plot(t,sin,'ro', t,cos,'g+-', t,gauss,':b')

            gcf().axes_size = [800 400];
        ]]>
        </scilab:image>
        <para>
        Vertical segments between two curves, with automatic colors, and using Global properties
        for markers styles. Targeting a defined axes.
        </para>
        <programlisting role="example"><![CDATA[
clf
subplot(1,3,3)
ax3 = gca();         // We will draw here later
xsetech([0 0 0.7 1]) // Defines the first Axes area
t = -3:%pi/20:7;
// Tuning markers properties
plot([t ;t],[sin(t) ;cos(t)],'marker','d','markerFaceColor','green','markerEdgeColor','yel')

// Targeting a defined axes
plot(ax3, t, sin)
 ]]></programlisting>
        <scilab:image><![CDATA[
            clf
            subplot(1,3,3)
            ax3 = gca();         // We will draw here later
            xsetech([0 0 0.7 1]) // Defines the first Axes area
            t = -3:%pi/20:7;
            // Tuning markers properties
            plot([t ;t],[sin(t) ;cos(t)],'marker','d','markerFaceColor','green','markerEdgeColor','yel')

            // Targeting a defined axes
            plot(ax3, t, sin)

            gcf().axes_size = [800 400];
        ]]>
        </scilab:image>
        <para/>
        <para/>
        <para>
            <emphasis role="bold">Case of a non-square Y matrix:</emphasis>
            When it is consistent and required, X or/and Y data are
            automatically transposed in order to become plottable.
        </para>
        <programlisting role="example"><![CDATA[
clf()
x = [5 6 7 8]
y = [1   1   1   1   8
     2   3   4   5   9
     3   4   5   6  10
     4   5   6   7  12];

// Only one matching possibility case: how to make 4 identical plots in 4 manners...
// x is 1x4 (vector) and y is 4x5 (non square matrix)
subplot(221); plot(x', y , "o-");    // OK as is
subplot(222); plot(x , y , "o-");    // x is transposed
subplot(223); plot(x', y', "o-");    // y is transposed
subplot(224); plot(x , y', "o-");    // x and y are transposed
 ]]></programlisting>
        <scilab:image>
            x = [5 6 7 8]
            y = [1   1   1   1   8
                 2   3   4   5   9
                 3   4   5   6  10
                 4   5   6   7  12];

            // Only one matching possibility case: how to make 4 identical plots in 4 manners...
            // x is 1x4 (vector) and y is 4x5 (non square matrix)
            subplot(221); plot(x', y , "o-");    // OK as is
            subplot(222); plot(x , y , "o-");    // x is transposed
            subplot(223); plot(x', y', "o-");    // y is transposed
            subplot(224); plot(x , y', "o-");    // x and y are transposed
        </scilab:image>
        <para>
            <emphasis role="bold">Case of a square Y matrix, and X implicit or square:</emphasis>
        </para>
        <programlisting role="example"><![CDATA[
clf
t = [1   1   1   1
     2   3   4   5
     3   4   5   6
     4   5   6   7];

subplot(231), plot(t,"o-") , title("plot(t)",  "fontsize",3)
subplot(234), plot(t',"o-"), title("plot(t'')", "fontsize",3)

subplot(232), plot(t,t,"o-") , title("plot(t, t)",  "fontsize",3)
subplot(233), plot(t,t',"o-"), title("plot(t,t'')", "fontsize",3)

subplot(235), plot(t', t,"o-"),  title("plot(t'', t)",   "fontsize",3)
subplot(236), plot(t', t',"o-"), title("plot(t'', t'')", "fontsize",3)

for i=1:6, gcf().children(i).data_bounds([1 3]) = 0.5; end
 ]]></programlisting>
        <scilab:image>
            clf
            t = [1   1   1   1
                 2   3   4   5
                 3   4   5   6
                 4   5   6   7];

            subplot(231), plot(t,"o-") , title("plot(t)",  "fontsize",3)
            subplot(234), plot(t',"o-"), title("plot(t'')", "fontsize",3)

            subplot(232), plot(t,t,"o-") , title("plot(t, t)",  "fontsize",3)
            subplot(233), plot(t,t',"o-"), title("plot(t,t'')", "fontsize",3)

            subplot(235), plot(t', t,"o-"),  title("plot(t'', t)",   "fontsize",3)
            subplot(236), plot(t', t',"o-"), title("plot(t'', t'')", "fontsize",3)

            for i=1:6, gcf().children(i).data_bounds([1 3]) = 0.5; end

            gcf().axes_size = [800 450];
        </scilab:image>
        <para>
            <emphasis role="bold">Special cases of a matrix X and a vector Y:</emphasis>
        </para>
        <programlisting role="example"><![CDATA[
clf
X = [1   1   1   1
     2   3   4   5
     3   4   5   6
     4   5   6   7];
y = [1 2 3 4];

subplot(221), plot(X, y,  "o-"), title("plot(X, row)",  "fontsize",3)
        // equivalent to plot(t, [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4])
subplot(223), plot(X, y', "o-"), title("plot(X, col)  (row = col'')",  "fontsize",3)
subplot(222), plot(X',y,  "o-"), title("plot(X'', row)",  "fontsize",3)
subplot(224), plot(X',y', "o-"), title("plot(X'', col)  (row = col'')",  "fontsize",3)

for i = 1:4, gcf().children(i).data_bounds([1 3]) = 0.5; end
 ]]></programlisting>
        <scilab:image>
            clf
            X = [1   1   1   1
                 2   3   4   5
                 3   4   5   6
                 4   5   6   7];
            y = [1 2 3 4];

            subplot(221), plot(X, y,  "o-"), title("plot(X, row)",  "fontsize",3)
                    // equivalent to plot(t, [1 1 1 1; 2 2 2 2; 3 3 3 3; 4 4 4 4])
            subplot(223), plot(X, y', "o-"), title("plot(X, col)  (row = col'')",  "fontsize",3)
            subplot(222), plot(X',y,  "o-"), title("plot(X'', row)",  "fontsize",3)
            subplot(224), plot(X',y', "o-"), title("plot(X'', col)  (row = col'')",  "fontsize",3)

            for i = 1:4, gcf().children(i).data_bounds([1 3]) = 0.5; end
        </scilab:image>
        <para/>
        <para>
            <emphasis role="bold">Post-tuning Axes and curves:</emphasis>
        </para>
        <programlisting role="example"><![CDATA[
x=[0:0.1:2*%pi]';
plot(x-4,sin(x),x+2,cos(x))

// axis centered at (0,0)
a=gca(); // Handle on axes entity
a.x_location = "origin";
a.y_location = "right";
isoview on

// Some operations on entities created by plot ...
a.children // list the children of the axes : here it is an Compound child composed of 2 entities
poly1= a.children.children(2); //store polyline handle into poly1
poly1.foreground = 4;  // another way to change the style...
poly1.thickness = 3;   // ...and the thickness of a curve.
poly1.clip_state='off' // clipping control
isoview off
 ]]></programlisting>
        <scilab:image>
            x = [0:0.1:2*%pi]';
            plot(x-4,sin(x),x+2,cos(x))
            a = gca();
            a.x_location = "origin";
            a.y_location = "origin";
            isoview on
            a.children
            poly1 = a.children.children(2);
            poly1.foreground = 4;
            poly1.thickness = 3;
            poly1.clip_state='off'
            isoview off
        </scilab:image>
    </refsection>
    <refsection role="see also">
        <title>Ver Também</title>
        <simplelist type="inline">
            <member>
                <link linkend="plot2d">plot2d</link>
            </member>
            <member>
                <link linkend="plot2d2">plot2d2</link>
            </member>
            <member>
                <link linkend="plot2d3">plot2d3</link>
            </member>
            <member>
                <link linkend="plot2d4">plot2d4</link>
            </member>
            <member>
                <link linkend="param3d">param3d</link>
            </member>
            <member>
                <link linkend="surf">surf</link>
            </member>
            <member>
                <link linkend="scf">scf</link>
            </member>
            <member>
                <link linkend="clf">clf</link>
            </member>
            <member>
                <link linkend="close">close</link>
            </member>
            <member>
                <link linkend="delete">delete</link>
            </member>
            <member>
                <link linkend="LineSpec">LineSpec</link>
            </member>
            <member>
                <link linkend="color_list">Cores nomeadas</link>
            </member>
            <member>
                <link linkend="GlobalProperty">GlobalProperty</link>
            </member>
        </simplelist>
    </refsection>
    <refsection role="history">
        <title>Histórico</title>
        <revhistory>
            <revision>
                <revnumber>6.0.1</revnumber>
                <revdescription>
                    The "color"|"foreground", "markForeground", and "markBackground" GlobalProperty
                    colors can now be chosen among the full predefined colors list, or by
                    their "#RRGGBB" hexadecimal codes, or by their indices in the colormap.
                </revdescription>
            </revision>
            <revision>
                <revnumber>6.0.2</revnumber>
                <revdescription>
                    Plotting a function func(x, params) with input parameters is now possible with
                    plot(x, list(func, params)).
                </revdescription>
            </revision>
            <revision>
                <revnumber>6.1.0</revnumber>
                <revdescription>
                    logflag option added.
                </revdescription>
            </revision>
            <revision>
                <revnumber>6.1.1</revnumber>
                <revdescription>
                    Polynomials and rationals can be plotted.
                </revdescription>
            </revision>
        </revhistory>
    </refsection>
</refentry>
