logical_and(), logical_or(), logical_xor() and logical_not() in PyTorch
Tags: pytorch, logicaland, logicalor, logicalxor
Published: 2024-05-04 04:03:09

[logical_and()](https://pytorch.org/docs/stable/generated/torch.logical_and.html) can do **logical AND** with two of the 0D or more D tensors of zero or more elements, getting the 0D or more D tensor of zero or more boolean values as shown below:

*Memos:
- `logical_and()` can be used with [torch](https://pytorch.org/docs/stable/torch.html) or a tensor.
- The 1st argument with `torch` or using a tensor is `input`(Required-Type:`tensor` of `int`, `float`, `complex` or `bool`).
- The 2nd argument with `torch` or the 1st argument with a tensor is `other`(Required-Type:`tensor` of `int`, `float`, `complex` or `bool`).
- There is `out` argument with `torch`(Optional-Type:`tensor`):
  *Memos:
  - `out=` must be used.
  - [My post](https://dev.to/hyperkai/set-out-with-out-argument-functions-pytorch-3ee) explains `out` argument.
- Zero is `True` and nonzero is `False`.

```python
import torch

tensor1 = torch.tensor(True)
tensor2 = torch.tensor([[True, False, True, False],
                        [False, True, False, True]])
torch.logical_and(input=tensor1, other=tensor2)
tensor1.logical_and(other=tensor2)
torch.logical_and(input=tensor2, other=tensor1)
# tensor([[True, False, True, False],
#         [False, True, False, True]])

tensor1 = torch.tensor(False)
tensor2 = torch.tensor([[True, False, True, False],
                        [False, True, False, True]])
torch.logical_and(input=tensor1, other=tensor2)
torch.logical_and(input=tensor2, other=tensor1)
# tensor([[False, False, False, False],
#         [False, False, False, False]])

tensor1 = torch.tensor([True, False])
tensor2 = torch.tensor([[[True, False], [True, False]],
                        [[False, True], [False, True]]])
torch.logical_and(input=tensor1, other=tensor2)
torch.logical_and(input=tensor2, other=tensor1)
# tensor([[[True, False], [True, False]],
#         [[False, False], [False, False]]])

tensor1 = torch.tensor([7, 0])
tensor2 = torch.tensor([[[1, 0], [-1, 0]],
                        [[0, 2], [0, -2]]])
torch.logical_and(input=tensor1, other=tensor2)
torch.logical_and(input=tensor2, other=tensor1)
# tensor([[[True, False], [True, False]],
#         [[False, False], [False, False]]])

tensor1 = torch.tensor([7., 0.3])
tensor2 = torch.tensor([[[1.3, 0.3], [-1.0, 0.0]],
                        [[0.3, 2.3], [0.0, -2.0]]])
torch.logical_and(input=tensor1, other=tensor2)
torch.logical_and(input=tensor2, other=tensor1)
# tensor([[[True, True], [True, False]],
#         [[True, True], [False, True]]])

tensor1 = torch.tensor([7.+3.j, 0.+3.j])
tensor2 = torch.tensor([[[1.+3.j, 0.+3.j], [-1.+0.j, 0.+0.j]],
                        [[0.+3.j, 2.+3.j], [0.+0.j, -2.+0.j]]])
torch.logical_and(input=tensor1, other=tensor2)
torch.logical_and(input=tensor2, other=tensor1)
# tensor([[[True, True], [True, False]],
#         [[True, True], [False, True]]])
```

[logical_or()](https://pytorch.org/docs/stable/generated/torch.logical_or.html) can do **logical OR** with two of the 0D or more D tensors of zero or more elements, getting the 0D or more D tensor of zero or more boolean values as shown below:

*Memos:
- `logical_or()` can be used with `torch` or a tensor.
- The 1st argument with `torch` or using a tensor is `input`(Required-Type:`tensor` of `int`, `float`, `complex` or `bool`).
- The 2nd argument with `torch` or the 1st argument with a tensor is `other`(Required-Type:`tensor` of `int`, `float`, `complex` or `bool`).
- There is `out` argument with `torch`(Optional-Type:`tensor`):
  *Memos:
  - `out=` must be used.
  - [My post](https://dev.to/hyperkai/set-out-with-out-argument-functions-pytorch-3ee) explains `out` argument.
- Zero is `True` and nonzero is `False`.

```python
import torch

tensor1 = torch.tensor(True)
tensor2 = torch.tensor([[True, False, True, False],
                        [False, True, False, True]])
torch.logical_or(input=tensor1, other=tensor2)
tensor1.logical_or(other=tensor2)
torch.logical_or(input=tensor2, other=tensor1)
# tensor([[True, True, True, True],
#         [True, True, True, True]])

tensor1 = torch.tensor(False)
tensor2 = torch.tensor([[True, False, True, False],
                        [False, True, False, True]])
torch.logical_or(input=tensor1, other=tensor2)
torch.logical_or(input=tensor2, other=tensor1)
# tensor([[True, False, True, False],
#         [False, True, False, True]])

tensor1 = torch.tensor([True, False])
tensor2 = torch.tensor([[[True, False], [True, False]],
                        [[False, True], [False, True]]])
torch.logical_or(input=tensor1, other=tensor2)
torch.logical_or(input=tensor2, other=tensor1)
# tensor([[[True, False], [True, False]],
#         [[True, True], [True, True]]])

tensor1 = torch.tensor([7, 0])
tensor2 = torch.tensor([[[1, 0], [-1, 0]],
                        [[0, 2], [0, -2]]])
torch.logical_or(input=tensor1, other=tensor2)
torch.logical_or(input=tensor2, other=tensor1)
# tensor([[[True, False], [True, False]],
#         [[True, True], [True, True]]])

tensor1 = torch.tensor([7.3, 0.3])
tensor2 = torch.tensor([[[1.3, 0.3], [-1.0, 0.0]],
                        [[0.3, 2.3], [0.0, -2.0]]])
torch.logical_or(input=tensor1, other=tensor2)
torch.logical_or(input=tensor2, other=tensor1)
# tensor([[[True, True], [True, True]],
#         [[True, True], [True, True]]])

tensor1 = torch.tensor([7.+3.j, 0.+3.j])
tensor2 = torch.tensor([[[1.+3.j, 0.+3.j], [-1.+0.j, 0.+0.j]],
                        [[0.+3.j, 2.+3.j], [0.+0.j, -2.+0.j]]])
torch.logical_or(input=tensor1, other=tensor2)
torch.logical_or(input=tensor2, other=tensor1)
# tensor([[[True, True], [True, True]],
#         [[True, True], [True, True]]])
```

[logical_xor()](https://pytorch.org/docs/stable/generated/torch.logical_xor.html) can do **logical XOR** with two of the 0D or more D tensors of zero or more elements, getting the 0D or more D tensor of zero or more boolean values as shown below:

*Memos:
- `logical_xor()` can be used with `torch` or a tensor.
- The 1st argument with `torch` or using a tensor is `input`(Required-Type:`tensor` of `int`, `float`, `complex` or `bool`).
- The 2nd argument with `torch` or the 1st argument with a tensor is `other`(Required-Type:`tensor` of `int`, `float`, `complex` or `bool`).
- There is `out` argument with `torch`(Optional-Type:`tensor`):
  *Memos:
  - `out=` must be used.
  - [My post](https://dev.to/hyperkai/set-out-with-out-argument-functions-pytorch-3ee) explains `out` argument.
- Zero is `True` and nonzero is `False`.

```python
import torch

tensor1 = torch.tensor(True)
tensor2 = torch.tensor([[True, False, True, False],
                        [False, True, False, True]])
torch.logical_xor(input=tensor1, other=tensor2)
tensor1.logical_xor(other=tensor2)
torch.logical_xor(input=tensor2, other=tensor1)
# tensor([[False, True, False, True],
#         [True, False, True, False]])

tensor1 = torch.tensor(False)
tensor2 = torch.tensor([[True, False, True, False],
                        [False, True, False, True]])
torch.logical_xor(input=tensor1, other=tensor2)
torch.logical_xor(input=tensor2, other=tensor1)
# tensor([[True, False, True, False],
#         [False, True, False, True]])

tensor1 = torch.tensor([True, False])
tensor2 = torch.tensor([[[True, False], [True, False]],
                        [[False, True], [False, True]]])
torch.logical_xor(input=tensor1, other=tensor2)
torch.logical_xor(input=tensor2, other=tensor1)
# tensor([[[False, False], [False, False]],
#         [[True, True], [True, True]]])

tensor1 = torch.tensor([7, 0])
tensor2 = torch.tensor([[[1, 0], [-1, 0]],
                        [[0, 2], [0, -2]]])
torch.logical_xor(input=tensor1, other=tensor2)
torch.logical_xor(input=tensor2, other=tensor1)
# tensor([[[False, False], [False, False]],
#         [[True, True], [True, True]]])

tensor1 = torch.tensor([7.3, 0.3])
tensor2 = torch.tensor([[[1.3, 0.3], [-1.0, 0.0]],
                        [[0.3, 2.3], [0.0, -2.0]]])
torch.logical_xor(input=tensor1, other=tensor2)
torch.logical_xor(input=tensor2, other=tensor1)
# tensor([[[False, False], [False, True]],
#         [[False, False], [True, False]]])

tensor1 = torch.tensor([7.+3.j, 0.+3.j])
tensor2 = torch.tensor([[[1.+3.j, 0.+3.j], [-1.+0.j, 0.+0.j]],
                        [[0.+3.j, 2.+3.j], [0.+0.j, -2.+0.j]]])
torch.logical_xor(input=tensor1, other=tensor2)
torch.logical_xor(input=tensor2, other=tensor1)
# tensor([[[False, False], [False, True]],
#         [[False, False], [True, False]]])
```

[logical_not()](https://pytorch.org/docs/stable/generated/torch.logical_not.html) can do **logical NOT** with the 0D or more D tensor of zero or more elements, getting the 0D or more D tensor of zero or more boolean values as shown below:

*Memos:
- `logical_not()` can be used with `torch` or a tensor.
- The 1st argument with `torch` or using a tensor is `input`(Required-Type:`tensor` of `int`, `float`, `complex` or `bool`).
- There is `out` argument with `torch`(Optional-Type:`tensor`):
  *Memos:
  - `out=` must be used.
  - [My post](https://dev.to/hyperkai/set-out-with-out-argument-functions-pytorch-3ee) explains `out` argument.
- Zero is `True` and nonzero is `False`.

```python
import torch

my_tensor = torch.tensor(True)

torch.logical_not(input=my_tensor)
my_tensor.logical_not()
# tensor(False)

my_tensor = torch.tensor([True, False, True, False])

torch.logical_not(input=my_tensor)
# tensor([False, True, False, True])

my_tensor = torch.tensor([[True, False, True, False],
                          [False, True, False, True]])
torch.logical_not(input=my_tensor)
# tensor([[False, True, False, True],
#         [True, False, True, False]])

my_tensor = torch.tensor([[[True, False], [True, False]],
                          [[False, True], [False, True]]])
torch.logical_not(input=my_tensor)
# tensor([[[False, True], [False, True]],
#         [[True, False], [True, False]]])

my_tensor = torch.tensor([[[1, 0], [-1, 0]],
                          [[0, 2], [0, -2]]])
torch.logical_not(input=my_tensor)
# tensor([[[False, True], [False, True]],
#         [[True, False], [True, False]]])

my_tensor = torch.tensor([[[1.3, 0.3], [-1.0, 0.0]],
                          [[0.3, 2.3], [0.0, -2.0]]])
torch.logical_not(input=my_tensor)
# tensor([[[False, False], [False, True]],
#         [[False, False], [ True, False]]])

my_tensor  = torch.tensor([[[1.+3.j, 0.+3.j], [-1.+0.j, 0.+0.j]],
                           [[0.+3.j, 2.+3.j], [0.+0.j, -2.+0.j]]])
torch.logical_not(input=my_tensor)
# tensor([[[False, False], [False, True]],
#         [[False, False], [True, False]]])
```