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

# bitor

bitwise logical OR between element-wise integers of 2 arrays

### Syntax

`w = bitor(u, v)`

### Parameters

u, v, w

scalars, vectors, matrices or hypermatrices of null or positive integers encoded as decimal or integer numbers of any signed or unsigned inttype.

 Sparse-encoded matrices are not accepted.

If `u` and `v` have the same type and inttype, this one is the working one. Otherwise,

• if `u` or `v` is decimal-encoded, the working inttype is 0 (real decimal), even if the other operand is int64- or uint64-encoded.
• if `u` and `v` are both encoded integers, the working inttype is the widest of both: int8 < uint8 < int16 < uint16 < int32 < uint32 < int64 < uint64.

The result `w` gets the type of the working encoding.

`u` and `v` are processed element-wise:

• If `u` is a single value (scalar) and `v` is a vector, matrix or hypermatrix, `u` is priorly expanded as `u*ones(v)` in order to operate `u` with every `v` component.
• Conversely, `v` is priorly expanded as `v*ones(u)` if it is a single value.
• If neither `u` nor `v` are scalars, they must have the same sizes.

`w` gets the sizes of `u` or/and `v` arrays.

### Description

For each pair of components `u(i)` and `v(i)`, `bitor(u, v)` computes and returns in `w(i)` the bitwise OR conjunction of `u(i)` and `v(i)` bits.
 With encoded integers, `bitor(u, v)` is equivalent to `u | v`. However, `u | v` demands that `u` and `v` have the same inttype, while `bitor(..)` accepts mixed operands.
 For any decimal integer `u` greater than 2^52, only its bits from log2(u) down to log2(u)-52 are encoded and can be actually taken into account. Lower bits are not stored and are then ignored.

### Examples

```bitor(25, 33)
dec2bin([25 33 57]')  // binary representations```
```--> bitor(25, 33)
ans  =
57.

--> dec2bin([25 33 57]'))
ans  =
!011001  !
!100001  !
!111001  !
```

```// Between 2 simple rows with zeros and ones
u = [0 1 0 1];
v = [0 0 1 1];
bitor(u, v)  // [0 1 1 1] expected

// Encoded integers such as int8 are accepted:
u = int8([0 1 0 1]);
v = int8([0 0 1 1]);
bitor(u, v)

// Operands of mixed types are accepted.
// The type of the result is decimal if a decimal operand is involved,
// or the widest integer one otherwise:
u = [0 1 0 1];
v = [0 0 1 1];
z = bitor(u, int64(v));         type(z)       // 1 : decimal representation
z = bitor(uint8(u), int8(v));   typeof(z)     // uint8
z = bitor(uint8(u), int32(v));  typeof(z)     // int32

// Usage with 2 matrices
u = [  1  2  4  8
25 33 25 33 ];
v = [  2  4  8 16
33 25 57 57 ];
bitor(u, v)      //  [ 3 6 12 24 ;  57 57 57 57 ]   expected

// Usage with a distributed scalar:
bitor([1 2 4 8 9 10 12], 8)  // == bitor([1 2 4 8 9 10 12], [8 8 8 8 8 8 8])
bitor(4, [1 2 4 8 9 10 12])  // == bitor([4 4 4 4 4 4 4], [1 2 4 8 9 10 12])```

```// With encoded integers, bitor(u,v) and u|v are equivalent:
u = int8([2 3 10]);
v = int8(6);
[bitor(u, v) ; u | v]
// ... but "|" demands operands with the same type:
u | 6    // mismatching int8- | decimal- encodings```
```--> u = int8([2 3 10]);
--> v = int8(6);
--> [bitor(u, v) ; u | v]
ans  =
6  7  14
6  7  14
--> u | 6
Undefined operation for the given operands.
```

```// Examples with big decimal integers:

u = sum(2 .^(600+[0 3 9 20 45]))        // ~ 1.46D+194
v = 2^630                               // ~ 4.46D+189
w = bitor(u, v)
w == (u+v)  // must be true, since u is built without the bit #630
bitor(u, 2^645) == u   // true, since u has already its bit #645 set to 1
bitor(u, 2^601) == u   // false
//
n = fix(log2(u))       // Index of the heaviest bit of u
bitor(u, 2^(n-52)) == u   // false: The lightest bit of u was at 0 => This changes it
bitor(u, 2^(n-53)) == u   // true: Addressing bits below the lightest doesn't change u```

• | — Binary OR between integers. Logical OR over/between booleans and numbers
• or — logical OR over the elements of a boolean or numerical array
• bitxor — bitwise logical XOR between element-wise integers of 2 arrays
• bitand — bitwise logical AND between element-wise integers of 2 arrays
• dec2bin — преобразование из десятичной системы счисления в двоичную

### History

 Версия Описание 6.0 Extension to positive signed encoded integers Extension to new int64 and uint64 inttypes Operands of mixed types or inttypes are now accepted. bitor(scalar, array) and bitor(array, scalar) are now supported. Extension to decimal numbers greater than 2^32 and even than 2^52, up to 1.80D+308 (== number_properties("huge")), for the 52 heaviest encoded bits of their unsigned mantissa.