Scilab Home page | Wiki | Bug tracker | Forge | Mailing list archives | ATOMS | File exchange
Change language to: English - Français - Português - 日本語 -

See the recommended documentation of this function

Справка Scilab >> Основные функции > |, ||

# |, ||

Binary OR between integers. Logical OR over/between booleans and numbers

### Syntax

Element-wise operator:

```intMat = intA | intB
tfMat = A | B```

Scalared short-circuited evaluation:

```tf = U || V
if (U || V) then ... end
if (U | V)  then ... end
while (U || V) then ... end
while (U | V) then ... end```

### Arguments

intA, intB

Arrays of encoded integers of any inttype.

`intA` and `intB` must have the same sizes to be processed element-wise. If `intA` or `intB` is a scalar, it is priorly replicated to the size of the other operand before processing.

If `intA` and `intB` have not the same integer inttype, the operand with the smaller encoding is converted to the wider according to the following ranks: int8 < uint8 < int16 < uint16 < int32 < uint32 < int64 < uint64.

intMat

Array of encoded integers with the same sizes of `intA` and `intB`, and of the wider inttype of both (see hereabove). For any index `i`, `intMat(i) = bitor(intA(i), intB(i))`

 `intA | []` and `[] | intA` return the boolean array `intA~=%nan`.

A, B

Arrays of booleans or of numbers: encoded integers of any inttype, real or complex numbers. `A` and `B` may have distinct types, and may be one or both sparse-encoded. The special case where `A` and `B` are both encoded integers is excluded (see here-above).

`A` and `B` must have the same sizes to be processed element-wise. If `A` or `B` is a scalar, it is priorly replicated to the size of the other operand before processing.

tfMat

Boolean array with the same sizes of `A` and `B`. If `A` or `B` is sparse-encoded, so is `tfMat`.

For any index `i`, `tfMat(i)` is `%T` if either `A(i)` or `B(i)` is `%T` or not zero. Otherwise, `tfMat(i)` is set to `%F`.

 `A | []` and `[] | A` return `[]`.

U, V

Arrays of full or sparse-encoded booleans or of numbers of any types and encoding: any inttype of encoded integers, full or sparse-encoded real or complex numbers.

`U` and `V` may have distinct data types, number of dimensions, and sizes.

tf

single boolean: `U || V` is equal to `or(U) | or(V)`, without evaluating `or(V)` if `or(U)` is true (this is why the `||` operator is so-called short-circuited).

See or() for the definition of the evaluation to true depending on type and encoding.

### Description

||

For any boolean or numerical operands `U` and `V`, `G = U || V` is equivalent to `if or(U), G = %T, else G = or(V), end`.

• `U` and `V` may have distinct sizes or numbers of dimensions.
• The result is always a single boolean.
• `or(V)` is evaluated only if `or(U)` is false. This mainly avoids yielding errors when further operations with `V` are meaningless or prone to error when `U` is true. See examples.

|

When the `|` operator is used inside a logical condition tested by a `while` or by an `if` control structure, it is equivalent to the `||` operator (see above).

Otherwise, `|` has two different actions:

1. When both operands are encoded integers, `intA | intB` is processed element-wise and yields an array of integers resulting from the bitwise `AND` between corresponding components.
2. Otherwise, when operands are arrays of numbers or/and booleans, they are still processed element-wise. Provided that null numbers are equivalent to false booleans, the result is an array of booleans.

Comparing `|` and `||` with `bitor()` and `or()` :

• `or(A)` is equivalent to `A || %F`, whereas `or(A, side)` has no equivalence with `||`.
• `intA | intB` accepts negative integers, while `bitor(intA, intB)` does not. `bitor(A,B)` works bitwise with decimal-encoded integers.

 The overloading code for `|` and `||` operators is g.
 `%nan` is `true`. A polynomial or rational is not considered as a number and is not an acceptable operand for `|` or `||`.

### Examples

```A = [0 1; 1 0];   // equivalent to [%f %t ; %t %f]
B = [1 1; 0 0];   // equivalent to [%t %t ; %f %f]
spA = sparse(A);
spB = sparse(B);
spbA = sparse(A<>0);
spbB = sparse(B<>0);
iA = int8(A);
iB = int8(B);
cA = A + 0*%i;
cB = B + 0*%i;

// | as logical operation
A | B
A | spB    // Result is sparse encoded
iA | spB   // Result is sparse encoded
cA | iB
A | %nan   // %nan is %t

// | as bitwise operation
iA | iB

Ai8 = int8([ -1, 1; 127, -128]);
// Integer representation of Ai8:
// [ 1111 1111, 0000 0001 ;
//   0111 1111, 1000 0000 ]

Bi8 = int8([-2, 0; 126, -127]);
// Integer representation of Bi8:
// [ 1111 1110, 0000 0000 ;
//   0111 1110, 1000 0001 ]

Ai8 | Bi8

// Integer promotion
Ai16  = int16(Ai8);
Bui32 = uint32(Bi8);

r = Ai16 | Bui32, typeof(r)

// Shorted | or ||:
// ----------------
function res=foo()
error("foo() shall not be called")
endfunction

// | (simple) is always shorted in any if's condition:
if  %T | foo() then
// foo() is not called and this is not executed
end

A  || foo()   // A, iA and cA have at least one non-zero element.
iA || foo()   // Therefore, foo() is not called
cA || foo()```

Avoiding conditional errors in `or` out of `if` and `while` conditions:

```A = [ 1 3 -2 ; 4 -1  2]
c = ~issquare(A) | det(A)~=0
// det(A) is evaluated despite ~issquare(A) is true (so c is true anyway)
// But A should be square to be able to compute its det(). ==> ERROR

// Now, we use the short-circuited || :
// det(A) is NO LONGER computed, since ~issquare(A) is true => anyway c is true
c = ~issquare(A) || det(A)~=0     // => NO ERROR

// In an "if" (or "while") tested condition, | is equivalent to ||
if ~issquare(A) | det(A)~=0       // => NO ERROR
B = A * A.'
end```
```--> A = [ 1 3 -2 ; 4 -1  2]
A  =
1.   3.  -2.
4.  -1.   2.

--> c = ~issquare(A) | det(A)~=0
det: Wrong type for input argument #1: Square matrix expected.

--> c = ~issquare(A) || det(A)~=0    // => NO ERROR
c  =
T

--> if ~issquare(A) | det(A)~=0      // => NO ERROR
>    B = A * A.'
> end
B  =
14.  -3.
-3.    21.
```

Constant polynomials or rationals can't be processed with | or ||:

```p = 1 + 0*%z
typeof(p)
p | 1```
```--> p = 1 + 0*%z
p  =
1

--> typeof(p)
ans  =
polynomial

--> p | 1
Undefined operation for the given operands.
```

• or — logical OR over the elements of a boolean or numerical array
• bitor — bitwise logical OR between element-wise integers of 2 arrays
• and operator (&) — Binary AND between integers. Logical AND over/between booleans and numbers
• not ~ — (~) логическое НЕ
• if — ключевое слово для условного выполнения
• while — ключевое слово while

### History

 Версия Описание 6.0 || operator added