arange() and linspace() in PyTorch
Tags: pytorch, arange, linspace, function
Published: 2024-07-10 15:08:08

*[My post](https://dev.to/hyperkai/logspace-in-pytorch-3dom) explains [logspace()](https://pytorch.org/docs/stable/generated/torch.logspace.html).

[arange()](https://pytorch.org/docs/stable/generated/torch.arange.html) can create the 1D tensor of zero or integers or floating-point numbers between `start` and `end-1`(`start`<=x<=`end-1`)as shown below:

*Memos:
- `arange()` can be used with [torch](https://pytorch.org/docs/stable/torch.html) but not with a tensor.
- The 1st argument with `torch` is `start`(Optional-Default:`0`-Type:`int`, `float`, `complex` or `bool`):
  *Memos
  - It must be lower than or equal to `end`. 
  - The 0D tensor of `int`, `float`, `complex` or `bool` also works.
- The 2nd argument with `torch` is `end`(Required-Type:`int`, `float`, `complex` or `bool`):
  *Memos:
  - It must be greater than or equal to `start`.
  - The 0D tensor of `int`, `float`, `complex` or `bool` also works.
- The 3rd argument with `torch` is `step`(Optional-Default:`1`-Type:`int`, `float`, `complex` or `bool`):
  *Memos:
  - It must be greater than 0.
  - The 0D tensor of `int`, `float`, `complex` or `bool` also works.
- There is `dtype` argument with `torch`(Optional-Type:[dtype](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype)):
  *Memos:
  - If `dtype` is not given, `dtype` is inferred from `start`, `end` or `step` or `dtype` of [set_default_dtype()](https://pytorch.org/docs/stable/generated/torch.set_default_dtype.html) is used for floating-point numbers.
  - `dtype=` must be used.
  - [My post](https://dev.to/hyperkai/set-dtype-with-dtype-argument-functions-and-get-it-in-pytorch-13h2) explains `dtype` argument.
- There is `device` argument with `torch`(Optional-Type:`str`, `int` or [device()](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device)):
  *Memos:
  - `device=` must be used.
  - [My post](https://dev.to/hyperkai/set-device-with-device-argument-functions-and-get-it-in-pytorch-1o2p) explains `device` argument.
- There is `requires_grad` argument with `torch`(Optional-Type:`bool`):
  *Memos:
  - `requires_grad=` must be used.
  - [My post](https://dev.to/hyperkai/set-requiresgrad-with-requiresgrad-argument-functions-and-get-it-in-pytorch-39c3) explains `requires_grad` argument.
- 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.
- There is [range()](https://pytorch.org/docs/stable/generated/torch.range.html) which is similar to `arange()` but `range()` is deprecated.

```python
import torch

torch.arange(end=5)
# tensor([0, 1, 2, 3, 4])

torch.arange(start=5, end=15)
# tensor([5, 6, 7, 8, 9, 10, 11, 12, 13, 14])

torch.arange(start=5, end=15, step=3)
# tensor([5, 8, 11, 14])

torch.arange(start=-5, end=5)
# tensor([-5, -4, -3, -2, -1, 0, 1, 2, 3, 4])

torch.arange(start=-5, end=5, step=3)
torch.arange(start=torch.tensor(-5),
             end=torch.tensor(5),
             step=torch.tensor(3))
# tensor([-5, -2, 1, 4])

torch.arange(start=-5., end=5., step=3.)
torch.arange(start=torch.tensor(-5.),
             end=torch.tensor(5.),
             step=torch.tensor(3.))
# tensor([-5., -2., 1., 4.])

torch.arange(start=-5.+0.j, end=5.+0.j, step=3.+0.j)
torch.arange(start=torch.tensor(-5.+0.j),
             end=torch.tensor(5.+0.j),
             step=torch.tensor(3.+0.j))
# tensor([-5., -2., 1., 4.])

torch.arange(start=False, end=True, step=True)
torch.arange(start=torch.tensor(False),
             end=torch.tensor(True),
             step=torch.tensor(True))
# tensor([0])
```

[linspace()](https://pytorch.org/docs/stable/generated/torch.linspace.html) can create the 1D tensor of the zero or more integers, floating-point numbers or complex numbers evenly spaced between `start` and `end`(`start`<=x<=`end`) as shown below:

*Memos:
- `linspace()` can be used with `torch` but not with a tensor.
- The 1st argument with `torch` is `start`(Required-Type:`int`, `float`, `complex` or `bool`). *The 0D tensor of `int`, `float`, `complex` or `bool` also works.
- The 2nd argument with `torch` is `end`(Required-Type:`int`, `float`, `complex` or `bool`). *The 0D tensor of `int`, `float`, `complex` or `bool` also works.
- The 3rd argument with `torch` is `steps`(Required-Type:`int`):
  *Memos:
  - It must be greater than or equal to 0.
  - The 0D tensor of `int` also works.
- There is `dtype` argument with `torch`(Optional-Type:[dtype](https://pytorch.org/docs/stable/tensor_attributes.html#torch.dtype)):
  *Memos:
  - If `dtype` is not given, `dtype` is inferred from `start`, `end` or `step` or `dtype` of [set_default_dtype()](https://pytorch.org/docs/stable/generated/torch.set_default_dtype.html) is used for floating-point numbers.
  - Setting `start` and `end` of integer type is not enough to create the 1D tensor of integer type so integer type with `dtype` must be set.
  - `bool` cannot be used.
  - `dtype=` must be used.
  - [My post](https://dev.to/hyperkai/set-dtype-with-dtype-argument-functions-and-get-it-in-pytorch-13h2) explains `dtype` argument.
- There is `device` argument with `torch`(Optional-Type:`str`, `int` or [device()](https://pytorch.org/docs/stable/tensor_attributes.html#torch.device)):
  *Memos:
  - `device=` must be used.
  - [My post](https://dev.to/hyperkai/set-device-with-device-argument-functions-and-get-it-in-pytorch-1o2p) explains `device` argument.
- There is `requires_grad` argument with `torch`(Optional-Type:`bool`):
  *Memos:
  - `requires_grad=` must be used.
  - [My post](https://dev.to/hyperkai/set-requiresgrad-with-requiresgrad-argument-functions-and-get-it-in-pytorch-39c3) explains `requires_grad` argument.
- 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.

```python
import torch

torch.linspace(start=10, end=20, steps=0)
torch.linspace(start=20, end=10, steps=0)
# tensor([])

torch.linspace(start=10., end=20., steps=1)
tensor([10.])

torch.linspace(start=20, end=10, steps=1)
# tensor([20.])

torch.linspace(start=10., end=20., steps=2)
# tensor([10., 20.])

torch.linspace(start=20, end=10, steps=2)
# tensor([20., 10.])

torch.linspace(start=10., end=20., steps=3)
# tensor([10., 15., 20.])

torch.linspace(start=20, end=10, steps=3)
# tensor([20., 15., 10.])

torch.linspace(start=10., end=20., steps=4)
# tensor([10.0000, 13.3333, 16.6667, 20.0000])

torch.linspace(start=20., end=10., steps=4)
# tensor([20.0000, 16.6667, 13.3333, 10.0000])

torch.linspace(start=10, end=20, steps=4, dtype=torch.int64)
torch.linspace(start=torch.tensor(10),
               end=torch.tensor(20),
               steps=torch.tensor(4),
               dtype=torch.int64)
# tensor([10.0000, 13.3333, 16.6667, 20.0000])

torch.linspace(start=10.+6.j, end=20.+3.j, steps=4)
torch.linspace(start=torch.tensor(10.+6.j),
               end=torch.tensor(20.+3.j),
               steps=torch.tensor(4))
# tensor([10.0000+6.j, 13.3333+5.j, 16.6667+4.j, 20.0000+3.j])

torch.linspace(start=False, end=True, steps=4)
torch.linspace(start=torch.tensor(True),
               end=torch.tensor(False),
               steps=torch.tensor(4))
# tensor([0.0000, 0.3333, 0.6667, 1.0000])

torch.linspace(start=10, end=20, steps=4, dtype=torch.int64)
torch.linspace(start=torch.tensor(10),
               end=torch.tensor(20),
               steps=torch.tensor(4), dtype=torch.int64)
# tensor([10.0000, 13.3333, 16.6667, 20.0000])
```