Please note that the recommended version of Scilab is 2025.0.0. This page might be outdated.
See the recommended documentation of this function
bitxor
bitwise logical XOR between element-wise integers of 2 arrays
Syntax
w = bitxor(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
andv
have the same type and inttype, this one is the working one. Otherwise,- if
u
orv
is decimal-encoded, the working inttype is 0 (real decimal), even if the other operand is int64- or uint64-encoded. - if
u
andv
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
andv
are processed element-wise:- If
u
is a single value (scalar) andv
is a vector, matrix or hypermatrix,u
is priorly expanded asu*ones(v)
in order to operateu
with everyv
component. - Conversely,
v
is priorly expanded asv*ones(u)
if it is a single value. - If neither
u
norv
are scalars, they must have the same sizes.
The result
w
gets the sizes ofu
or/andv
arrays.- if
Description
For each pair of componentsu(i)
and v(i)
,
bitxor(u, v)
computes and returns in w(i)
the bitwise XOR eXclusive-OR conjunction of u(i)
and
v(i)
bits.
With encoded integers, bitxor(u,v) is equivalent
to (u | v) & ~(u & v) .
However, both | and &
operators demand that u and v
have the same inttype, while bitxor(..) 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
bitxor(25, 33) dec2bin([25 33 56]') // binary representations
--> bitxor(25, 33) ans = 56. --> dec2bin([25 33 56]')) ans = !011001 ! !100001 ! !111000 !
// Between 2 simple rows with zeros and ones u = [0 1 0 1]; v = [0 0 1 1]; bitxor(u, v) // [0 1 1 0] expected // Encoded integers such as int8 are accepted: u = int8([0 1 0 1]); v = int8([0 0 1 1]); bitxor(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 = bitxor(u, int64(v)); type(z) // 1 : decimal representation z = bitxor(uint8(u), int8(v)); typeof(z) // uint8 z = bitxor(uint8(u), int32(v)); typeof(z) // int32 // Usage with 2 matrices u = [ 1 2 4 8 25 33 25 33 ]; v = [ 2 2+4 4+8 16 33 25 56 56 ]; bitxor(u, v) // [ 3 4 8 24 ; 56 56 33 25 ] expected // Usage with a distributed scalar: bitxor([1 2 4 8 9 10 12], 8) // == bitxor([1 2 4 8 9 10 12], [8 8 8 8 8 8 8]) bitxor(4, [1 2 4 8 9 10 12]) // == bitxor([4 4 4 4 4 4 4], [1 2 4 8 9 10 12])
// Examples with big decimal integers: u = sum(2 .^(600+[0 3 9 20 45])) // ~ 1.46D+194 bitxor(u, 2^630) == u+2^630 // true: XOR sets to 1 the missing bit #630 of u, so adds it bitxor(u, 2^645) == u-2^645 // true: XOR sets to 0 the existing bit #645 of u, so removes it bitxor(u, 2^601) == u // false: The bit #601 is 0 in u. XOR changes it. // n = fix(log2(u)) // 645 == Index of the heaviest bit of u bitxor(u, 2^(n-52)) == u // false: The lightest bit of u was at 0 => This changes it bitxor(u, 2^(n-53)) == u // true: Addressing bits below the lightest one doesn't change u
See also
- | — Binary OR between integers. Logical OR over/between booleans and numbers
- or — logical OR over the elements of a boolean or numerical array
- bitor — bitwise logical OR between element-wise integers of 2 arrays
- bitand — bitwise logical AND between element-wise integers of 2 arrays
- dec2bin — 10進数から2進数への変換
History
Version | Description |
6.0 |
|
Report an issue | ||
<< bitset | bitwise | Complex >> |