Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Please login or create an account
Change language to: English - Português - 日本語 - Русский

Please note that the recommended version of Scilab is 6.0.2. This page might be outdated.
See the recommended documentation of this function

Aide Scilab >> Scilab > Mots clés Scilab > comparison

# comparison

comparison, relational operators

```a==b
a~=b or a<>b
a<b
a<=b
a>b
a>=b```

### Arguments

a

any type of variable for `a==b`, `a~=b` `a<>b` equality comparisons and restricted to real floating point and integer array for order related comparisons `a<b`, `a<=b`, `a>b`, `a>=b`.

b

any type of variable for `a==b`, `a~=b` `a<>b` equality comparisons and restricted to real floating point and integer arrays for order related comparisons `a<b`, `a<=b`, `a>b`, `a>=b`.

### Description

Two classes of operators have to be distinguished:

The equality and inequality comparisons:

`a==b`, `a~=b` (or equivalently `a<>b`). These operators apply to any type of operands.

The order related comparisons:

`a<b`, `a<=b`, `a>b`, `a>=b`. These operators apply only to real floating point and integer arrays.

The semantics of the comparison operators also depend on the operands types:

With array variables

like floating point and integer arrays, logical arrays, string arrays, polynomial and rational arrays, handle arrays, lists... the following rules apply:

• If `a` and `b` evaluates as arrays with same types and identical dimensions, the comparison is performed element by element and the result is an array of booleans of the same size.

• If `a` and `b` evaluates as arrays with same types, but `a` or `b` is a scalar, then the scalar is compared with each element of the other array. The result is an array of booleans of the size of the non scalar operand.

• In the others cases the result is the boolean `%f`

• If the operand data types are different but "compatible" like floating points and integers, then a type conversion is performed before the comparison.

With other type of operands

like `function`, `libraries`, the result is `%t` if the objects are identical and `%f` in the other cases.

Equality comparison between operands of incompatible data types returns `%f`.

### Examples

```//element wise comparisons
(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])

//object wise comparisons
(1:10)==[4,3]
'foo'==3
1==[]
list(1,2,3)==1

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

//comparison with type conversion
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```

### See Also

• less — (<) less than comparison
• greater
• boolean — Objets Scilab, variables booléennes et opérateurs & | ~
• isequal — objects comparison

### Comments

Add a comment:
Please login to comment this page.

 Report an issue << try Mots clés Scilab dollar >>

 Scilab EnterprisesCopyright (c) 2011-2017 (Scilab Enterprises)Copyright (c) 1989-2012 (INRIA)Copyright (c) 1989-2007 (ENPC)with contributors Last updated:Tue Apr 02 17:36:44 CEST 2013