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`.

- Polynomials: `%s==%z` returns `%F` : Two polynomials can't be considered as equal if they are not about the same variable.

- Rationals: `1/%s == 1/%z` returns `%F` : Two rationals can't be equal if they are not about the same variable. In addition, the same rational may have different unnormalized forms that won't be considered as equal. For instance, `2/(2*%z) == 1/%z` returns `%F`, even in `simp_mode(%T)` simplification mode.

- Sparse numerical matrix: any element-wise comparison with a full-encoded numerical array always returns a boolean sparse array. See examples.

- Graphics identifiers: A graphic handle `h1` and its copy `h2=h1` will always stay equal, even if the graphics is changed through one of them. See examples.

## 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)

Comparisons with implicit conversion of type or encoding:

    int32(1) == 1
    int32(1) < 1.5
    int32(1:5) < int8(3)
    1 == complex(1,0)
    1 > complex(1,0)  // still OK, but..
    1 > complex(1,1)  // => error: complex numbers not orderable

    --> int32(1) == 1
     ans  =
      T

    --> int32(1) < 1.5
     ans  =
      T

    --> int32(1:5) < int8(3)
     ans  =
      T T F F F

    --> 1 == complex(1,0)
     ans  =
      T

    --> 1 > complex(1,0)  // still OK, but..
     ans  =
      F

    --> 1 > complex(1,1)  // => error: complex numbers not orderable
    at line    11 of function %s_2_s ( SCI\modules\overloading\macros\%s_2_s.sci line 23 )
    Complex comparison not supported. Please define %s_2_s_custom() or check your code.

Comparisons with polynomials and rationals:

    p = 0*%s
    p == 0
    r = p/(1+0*%s)
    r == 0
    r == p
    ps = (1-%s)^2, pz = (1-%z)^2
    ps == pz  // => %F : same variable required

    --> p = 0*%s
     p  =
       0

    --> p == 0
     ans  =
      T

    --> r = p/(1+0*%s)
     r  =
       0
       --
       1

    --> r == 0
     ans  =
      T

    --> r == p
     ans  =
      T

    --> ps = (1-%s)^2, pz = (1-%z)^2
     ps  =
                 2
       1  -2s +s
     pz  =
                 2
       1  -2z +z

    --> ps == pz  // => %F : same variable required
     ans  =
      F

Comparisons with a sparse numerical matrix: All element-wise comparisons yield a sparse-encoded result, `%F` otherwise.

    sp = sparse([0 1 0 0 -2 0 4 0 0])
    sp < 0
    sp == 1
    sp >=       [2 3 -1 2 -4 0 3 1 0]
    sp == %i
    sp == list(3) // => %F

    --> sp = sparse([0 1 0 0 -2 0 4 0 0])
     sp  =
    (  1,  9) sparse matrix
    (  1,  2)     1.
    (  1,  5)    -2.
    (  1,  7)     4.

    --> sp < 0
     ans  =
    (  1,  9) sparse matrix
    (  1,  5)   T

    --> sp == 1
     ans  =
    (  1,  9) sparse matrix
    (  1,  2)   T

    --> sp >= [2 3 -1 2 -4 0 3 1 0]
     ans  =
    (  1,  9) sparse matrix
    (  1,  3)   T
    (  1,  5)   T
    (  1,  6)   T
    (  1,  7)   T
    (  1,  9)   T

    --> sp == %i
     ans  =
    (  1,  9)False sparse matrix

    --> sp == list(3)  // object comparison => dense %F
     ans  =
      F

Comparisons between graphics identifiers:

    plot2d()
    e1 = gce();
    e2 = e1;    // e1 and e2 point to the same graphical object
    e2.tag
    e1.tag = "3 curves";
    e1 == e2
    e2.tag

    --> e2.tag
     ans  =

    --> e1.tag = "3 curves";
    --> e1 == e2
     ans  =
      T

    --> e2.tag
     ans  =
     3 curves

Comparisons between functions aliases are possible:

    sine = sin ;
    sine == sin
    seno = sind ;
    seno == sind
    seno(0:90:360)

    --> sine = sin ;
    --> sine == sin
     ans  =
      T

    --> seno = sind ;
    --> seno == sind
     ans  =
      T

    --> seno(0:90:360)
     ans  =
       0.   1.   0.  -1.   0.

## Ver Também

- less
- greater
- equal
- isequal
- boolean

## Histórico

6.0

- `~` (not) priority is now higher than the comparisons one (`== ~= < <= >= >`).
- Complex numbers with a null imaginary part are now compared as real numbers.