# bitxor

## Syntax

``C = bitxor(A,B)``
``C = bitxor(A,B,assumedtype)``
``objout = bitxor(netobj1,netobj2)``

## Description

example

````C = bitxor(A,B)` returns the bit-wise XOR of `A` and `B`. ```

example

````C = bitxor(A,B,assumedtype)` assumes that `A` and `B` are of `assumedtype`.```
````objout = bitxor(netobj1,netobj2)` returns the bit-wise XOR of the .NET enumeration objects `netobj1` and `netobj2`.```

## Examples

collapse all

Create a truth table for the logical XOR operation.

```A = uint8([0 1; 0 1]); B = uint8([0 0; 1 1]); TTable = bitxor(A, B)```
```TTable = 2x2 uint8 matrix 0 1 1 0 ```

`bitxor` returns 0 if both bit-wise inputs are equal.

MATLAB® encodes negative integers using two's complement. For example, to find the two's complement representation of -5, you take the bit pattern of the positive version of the number (`00000101`), swap each bit (`11111010`), and then add 1 to the result (`11111011`).

Therefore, the bit-wise XOR of -5 (`11111011`) and 6 (`00000110`) is -3 (`11111101`).

```a = -5; bitget(a,8:-1:1,'int8')```
```ans = 1×8 1 1 1 1 1 0 1 1 ```
```b = 6; bitget(b,8:-1:1,'int8')```
```ans = 1×8 0 0 0 0 0 1 1 0 ```
`c = bitxor(a,b,'int8')`
```c = -3 ```
`bitget(c,8:-1:1,'int8')`
```ans = 1×8 1 1 1 1 1 1 0 1 ```

## Input Arguments

collapse all

Input values, specified as scalars, vectors, matrices, or multidimensional arrays. Inputs `A` and `B` must either be the same size or have sizes that are compatible (for example, `A` is an `M`-by-`N` matrix and `B` is a scalar or `1`-by-`N` row vector). For more information, see Compatible Array Sizes for Basic Operations. `A` and `B` also must be the same data type unless one is a scalar double.

• If `A` and `B` are double arrays, and `assumedtype` is not specified, then MATLAB® treats `A` and `B` as unsigned 64-bit integers.

• If `assumedtype` is specified, then all elements in `A` and `B` must have integer values within the range of `assumedtype`.

Data Types: `double` | `logical` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Assumed data type of `A` and `B`, specified as `'uint64'`, `'uint32'`, `'uint16'`, `'uint8'`, `'int64'`, `'int32'`, `'int16'`, or `'int8'`.

• If `A` and `B` are double arrays, then `assumedtype` can specify any valid integer type, but defaults to `'uint64'`.

• If `A` and `B` are integer type arrays, then `assumedtype` must specify that same integer type.

Data Types: `char` | `string`

Input values, specified as .NET enumeration objects. You must be running a version of Windows® to use .NET enumeration objects as input arguments.

`bitxor` is an instance method for MATLAB enumeration objects created from a .NET enumeration.

## Output Arguments

collapse all

Bit-wise XOR result, returned as an array. `C` is the same data type as `A` and `B`.

• If either `A` or `B` is a scalar double, and the other is an integer type, then `C` is the integer type.

Bit-wise XOR result, returned as a .NET enumeration objects.