# comparison

comparação, operadores relacionais

## Seqüência de Chamamento

    a==b
                a~=b ou a<>b
                a<b
                a<=b
                a>b
                a>=b

## Parâmetros

a

  qualquer tipo de variável para comparações de igualdade `a==b`, `a~=b` `a<>b` e restrita a arrays de pontos flutuantes reais e inteiros para comparações relacionadas à ordem `a<b`, `a<=b`, `a>b`,`a>=b`.

b

  qualquer tipo de variável para comparações de igualdade `a==b`, `a~=b` `a< > b` erestrita a arrays de ponto flutuantes reais e inteiros para comparações relacionadas à ordem `a<b`, `a<=b`, `a>b`,`a>=b`.

## Descrição

Duas classes de operadores devem ser distinguidas:

Comparações de igualdade e desigualdade:

  `a==b`, `a~=b` (ou de modo equivalente `a<>b`). Estes operadores se aplicam a quaisquer tipos de operandos.

Comparações de ordem:

  `a<b`, `a<=b`, `a>b`,`a>=b`. Estes operadores se aplicam apenas a arrays de pontos flutuantes reais e inteiros.

A semântica dos operadores de comparação também depende dos tipos de operandos:

Com variáveis arrays

  como arrays de pontos flutuantes ou inteiros, arrays lógicos, arrays de strings, arrays de polinômios ou razões de polinômios, arrays de manipuladores, listas,... o seguinte se aplica:

  - Se `a` e `b` são avaliados como arrays do mesmo tipo e dimensões idênticas, a comparação é realizada elemento a elemento e o resultado é um array de booleanos da comparação.

  - Se `a` e `b` são avaliados como arrays do mesmo tipo, mas `a` ou `b` é um array 1 por 1, o elemento é comparado com cada elemento do outro array. O resultado é um array de booleanos com o tamanho do operando não-escalar.

  - Em outros casos, o resultado é o booleano `%f`

  - Se os tipos de dados dos operandos são diferentes, mas "compatíveis", como pontos flutuantes e inteiros, uma conversão de tipo é realizada antes da comparação.

Com outros tipos de operandos

  como `function`, `libraries`, o resultado é `%t` se os objetos são idênticos e `%f` em outros casos.

  Comparação de igualdade entre operandos com tipos de dados incompatíveis retorna `%f`.

## Exemplos

    //comparações elemento a elemento
    (1:5)==3
    (1:5)<=4
    (1:5)<=[1 4 2 3 0]
    1<[]
    list(1,2,3)~=list(1,3,3)
    "foo"=="bar"
    sparse([1,2;4,5;3,10],[1,2,3]) == sparse([1,2;4,5;3,10],[1,2,3])

    //comparações objeto a objeto
    (1:10)==[4,3]
    'foo'==3
    1==[]
    list(1,2,3)==1

    isequal(list(1,2,3),1)
    isequal(1:10,1)

    //comparação com conversão de tipo
    int32(1)==1
    int32(1)<1.5
    int32(1:5)<int8(3)
    p=poly(0,'s','c')
    p==0
    p/poly(1,'s','c')==0

## Ver Também

- less
- greater
- boolean
- isequal