bitwise logical OR between element-wise integers of 2 arrays
w = bitor(u, v)
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,
u
or v
is decimal-encoded, the working inttype is 0
(real decimal), even if the other operand
is int64- or uint64-encoded.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:
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.v
is priorly
expanded as v*ones(u)
if it
is a single value.u
nor v
are scalars, they must have the same sizes.w
gets the sizes of
u
or/and v
arrays.
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. |
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. check or define function %i_g_s for overloading.
// 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 | ![]() | ![]() |
Version | Description |
6.0 |
|