comparison

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