# bitor

## Syntax

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

## Description

example

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

example

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

## Examples

collapse all

Create a truth table for the logical OR operation.

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

`bitor` returns 1 if either bit-wise input is 1.

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 OR of -5 (`11111011`) and 6 (`00000110`) is -1 (`11111111`).

```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 = bitor(a,b,'int8')`
```c = -1 ```
`bitget(c,8:-1:1,'int8')`
```ans = 1×8 1 1 1 1 1 1 1 1 ```

Use `bitor` and `bitshift` to pack four 8-bit bytes into the 32-bit integer they make up.

Create four bytes of data. Specify the data with hexadecimal literals, using the `-u32` suffix to specify that the data should be stored as `uint32`. Each byte contains 8 bits worth of data.

```byte4 = 0x87u32; byte3 = 0x65u32; byte2 = 0x43u32; byte1 = 0x21u32;```

Start by adding the first byte as the first 8 bits of a 32-bit unsigned integer.

`packedNum = byte1;`

Next, pack the other three bytes into `packedNum`, using `bitshift` to shift the bytes to the proper locations, and `bitor` to copy the bits over.

```packedNum = bitor(packedNum,bitshift(byte2,8)); packedNum = bitor(packedNum,bitshift(byte3,8*2)); packedNum = bitor(packedNum,bitshift(byte4,8*3));```

View the packed 32-bit integer.

```format hex packedNum```
```packedNum = uint32 87654321 ```

## 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.

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

## Output Arguments

collapse all

Bit-wise OR 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 OR result, returned as a .NET enumeration objects.