# plot

Esboço 2d

## Seqüência de Chamamento

    plot(y,<LineSpec>,<GlobalProperty>)
                plot(x,y,<LineSpec>,<GlobalProperty>)
                plot(x1,y1,<LineSpec1>,x2,y2,<LineSpec2>,...xN,yN,<LineSpecN>,<GlobalProperty1>,<GlobalProperty2>,..<GlobalPropertyM>)
                plot(<axes_handle>,...)

## Parâmetros

x

  uma matriz ou vetor de reais. Se omitido, é assumido como sendo o vetor `1:n` onde `n` é o número de pontos de curva dado pelo parâmetro `y`.

y

  uma matriz de reais ou um vetor. `y` também pode ser uma função definida como um macro ou uma primitiva.

<LineSpec>

  este argumento opcional deve ser usado como um atalho para especificar um modo de desenhar uma linha. Podemos ter um `LineSpec` por`y` ou `{x,y}` previamente entrados. As opções `LineSpec` lidam com os especificadores LineStyle, Marker e Color (ver LineSpec). Estes especificadores determinam o estilo de linha, de marcas e a cor das linhas esboçadas.

<GlobalProperty>

  este argumento opcional representa uma seqüência de pares de declarações `{PropertyName,PropertyValue}` 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 GlobalProperty.

<axes_handle>

  este argumento opcional força o esboço a aparecer dentro dos eixos selecionados fornecidos por `axes_handle` ao invés dos eixos correntes (ver gca).

## Descrição

`plot` esboça um conjunto de curvas 2d. `plot` foi reconstruído para lidar melhor com a sintaxe do Matlab. Para melhorar a compatibilidade gráfica com o Matlab, utilize `plot` (ao invés de plot2d).

Especificação de entrada de dados:

Neste parágrafo, para sermos mais claros, não mencionaremos os argumentos opcionais `LineSpec` ou `GlobalProperty` já que eles não interferem na entrada de dados (exceto pelas propriedades `"Xdata"`, `"Ydata"` e `"Zdata"`, ver GlobalProperty). É assumido que todos estes argumentos podem estar presentes também.

Se `y` é um vetor, plot(y) esboça um vetor `y` versus o vetor `1:size(y,'*')`.

Se `y` é uma matriz, plot(y) esboça cada coluna de `y` versus o vetor `1:size(y,1)`.

Se `x` e `y` são vetores, plot(x,y) esboça o vetor `y` versus o vetor `x`. Os vetores `x` e `y` devem ter o mesmo número de entradas.

Se `x` é um vetor e `y` uma matriz plot(x,y) esboça cada coluna de `y` versus o vetor `x`. Neste caso, o número de colunas de `y` deve ser igual ao número de entradas de `x`.

Se `x` e `y` são matrizes, plot(x,y) esboça cada coluna de `y` versus a coluna correspondente de `x`. Neste caso, os tamanhos `x` e `y` devem ser os mesmos.

Finalmente, se apenas `x` ou `y` é 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 `x` ou penas `y`), a prioridade é dada a colunas ao invés de linhas (ver exemplos abaixo).

`y` também pode ser uma função definida como um macro ou uma primitiva. Neste caso, os dados `x` devem ser fornecidos (como um vetor ou uma matriz) e a computação correspondente de `y(x)` é feita implicitamente.

Os argumentos `LineSpec` e `GlobalProperty` devem ser utilizados para customizar o esboço. Aqui está uma lista completa das opções disponíveis.

LineSpec

  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.

  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 : `'r--d'` ou `'--dire'` ou `'--reddiam'` ou outra sentença sem ambigüidade... ou de modo completo `'diamondred--'` (ver LineSpec).

  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 polyline_properties).

GlobalProperty

  esta opção pode ser utilizada para especificar como as linhas serão desenhadas com mais opções que via `LineSpec`. Deve sempre ser um par de declarações constituidos de um string definindo `PropertyName`, (nome da propriedade) e seu valor associado `PropertyValue` (que pode ser um string, um inteiro ou qualquer outra coisa... dependendo do tipo de `PropertyName`). Utilizando-se `GlobalProperty`, 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 GlobalProperty)

  Note que todas as propriedades podem ser (re-)ajustadas através das propriedades de entidades poligonais (ver polyline_properties).

## Observações

Por padrão, esboços sucessivos são superpostos. Para limpar o esboço anterior, use `clf()`. Para habilitar o modo `auto_clear` (limpeza automática) como modo padrão, edite seus eixos fazendo o seguinte:

da=gda();

da.auto_clear = 'on'

Para uma melhor exibição, a função `plot` pode modificar a propriedade `box` de seu Axes (eixos) raíze. Isto acontece quando uma entidade Axes é criada por uma chamada a `plot` ou é vazia antes da chamada. Se um dos eixos é centrado na origem, box é desabilitado. Em caso contrário, box é habilitado.

Para mais informações sobre a propriedade box e sobre o posicionamento dos eixos, veja axes_properties

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:

`R` | `G` | `B`
0. | 0. | 1.
0. | 0.5 | 0.
1. | 0. | 0.
0. | 0.75 | 0.75
0.75 | 0. | 0.75
0.75 | 0.75 | 0.
0.25 | 0.25 | 0.25

Entre com o comando `plot` para visualizar uma demonstração.

## Exemplos

    // inicialização de x
    x=[0:0.1:2*%pi]';
    //esboço simples
    plot(sin(x))
    clf()
    plot(x,sin(x))
    //esboços múltiplos
    clf()
    plot(x,[sin(x) sin(2*x) sin(3*x)])
    clf()

    // eixo à direita
    plot(x,sin(x))
    a=gca(); // manipulador da entidade Axes
    a.y_location ="right";
    clf()

    // eixo centrado em (0,0)
    plot(x-4,sin(x),x+2,cos(x))
    a=gca(); // manipulador da entidade Axes
    a.x_location = "middle";
    a.y_location = "middle";

    // algumas operações em entidades criadas por plot...
    a=gca();
    a.isoview='on';
    a.children // listando os galhos da entidade Axes: aqui, é um galho Compound composto por duas entidades
    poly1= a.children.children(2); //armazenando um manipulador Polyline em poly1
    poly1.foreground = 4; // outro modo de se mudar o estilo...
    poly1.thickness = 3;  // ...e a espessura de uma curva.
    poly1.clip_state='off' // controle de recorte
    a.isoview='off';

    //exemplos com LineSpec e GlobalProperty:
    clf();
    t=0:%pi/20:2*%pi;
    plot(t,sin(t),'ro-.',t,cos(t),'cya+',t,abs(sin(t)),'--mo')
    scf(2)
    plot([t ;t],[sin(t) ;cos(t)],'xdat',[1:2])
    scf(3)
    axfig3 = gca();
    scf(4) // deveria permanecer em branco
    plot(axfig3,[t ;t],[sin(t) ;cos(t)],'zdat',[1:2],'marker','d','markerfac','green','markeredg','yel')
    xdel(winsid())

    //especificação de dados
    t=-%pi:0.1:%pi;
    size(t)
    plot(t) // esboços simples de y versus tamanho do vetor t
    clf(); // limpando figura

    plot(t,sin(t)); // esboça sin(t) versus t
    clf();

    t=[1     1     1     1
       2     3     4     5
       3     4     5     6
       4     5     6     7];

    plot(t) // esboça cada coluna t column versus tamanho de linha
    clf();

    subplot(221)
    plot(t,sin(t)); // esboça sin(t) versus t coluna por coluna desta vez
    xtitle("sin(t) versus t")
    subplot(222)
    plot(t,sin(t)')
    xtitle("sin(t)'' versus t")
    subplot(223)
    plot(t',sin(t))
    a=gca();
    a.data_bounds=[0 -1;7 1]; // para ver a linha vertical escondida pelo eixo y
    xtitle("sin(t) versus t''")
    subplot(224)
    plot(t',sin(t)')
    xtitle("sin(t)'' versus t''")

    clf();

    //caso especial 1
    //x : vector ([5 6 7 8]) and y : matrix (t)
    x=[5 6 7 8]
    plot(x,t);
    plot(x',t); // idem, x é automaiticamente transposto para corresponder a t (aqui as colunas)
    clf()

    // apenas um caso de possibilidade de correspondência: como realizar quatro esboços idênticos 4 de quatro maneiras 4...
    // x é um vetor 1x4 (vector) y is uma matriz não-quadrada 4x5
    subplot(221);
    plot(x,[t [8;9;10;12]]');
    subplot(222);
    plot(x',[t [8;9;10;12]]');
    subplot(223);
    plot(x,[t [8;9;10;12]]');
    subplot(224);
    plot(x',[t [8;9;10;12]]');
    clf()

    //caso especial 2
    // caso onde apenas x ou y é uma matriz quadrada
    //x : matrix (t) e y  : vetor ([1 2 3 4])
    plot(t,[1 2 3 4]) // equivalente a plot(t,[1 1 1 1;2 2 2 2;3 3 3 3;4 4 4 4])
    plot(t,[1;2;3;4]) // o mesmo esboço
    clf();

    // t é transposto: note a prioridade dada ao tratamento das colunas
    plot(t',[1 2 3 4]) // equivalente a plot(t',[1 1 1 1;2 2 2 2;3 3 3 3;4 4 4 4])
    plot(t',[1 2 3 4]') // o mesmo esboço
    clf();

    // y é uma função definida por...
    // ..uma primitiva
    plot(1:0.1:10,sin) // equivalente a plot(1:0.1:10,sin(1:0.1:10))
    clf();

    // ...uma macro:
    deff('[y]=toto(x)','y=x.*x')
    plot(1:10,toto)

## Ver Também

- plot2d
- surf
- scf
- clf
- xdel
- delete
- LineSpec
- GlobalProperty