torchwrench.types.tensor_subclasses module

Tensor subclasses for typing and instance checks.

Note: torchwrench.FloatTensor != torch.FloatTensor which is caused by issubclass(torchwrench.FloatTensor, torch.FloatTensor) is False because torch.FloatTensor cannot be subclassed

Here is an overview of the valid tensor subclasses tree:

Tensor

ComplexFloatingTensor RealTensor
|

+————+————+ +—————————+—————————-+ | | | | |

CHalfTensor CFloatTensor CDoubleTensor FloatingTensor IntegralTensor
(c32) (c64) (c128) | |

+———–+———–+ +——————+——————+ | | | | |

HalfTensor FloatTensor DoubleTensor SignedIntegerTensor UnsignedIntegerTensor
(f16) (f32) (f64) | |

+———–+—–+—–+———–+ +—–+—–+ | | | | | |

CharTensor ShortTensor IntTensor LongTensor ByteTensor BoolTensor

(i8) (i16) (i32) (i64) (u8) (bool)

class torchwrench.types.tensor_subclasses.BoolTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.BoolTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[bool], int, bool, Literal[False], Literal[False], Literal[False]]

class torchwrench.types.tensor_subclasses.BoolTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.BoolTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[bool], Literal[0], bool, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.BoolTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.BoolTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[bool], Literal[1], bool, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.BoolTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.BoolTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[bool], Literal[2], bool, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.BoolTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.BoolTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[bool], Literal[3], bool, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ByteTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ByteTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[uint8], int, int, Literal[False], Literal[False], Literal[False]]

class torchwrench.types.tensor_subclasses.ByteTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ByteTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[uint8], Literal[0], int, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ByteTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ByteTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[uint8], Literal[1], int, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ByteTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ByteTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[uint8], Literal[2], int, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ByteTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ByteTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[uint8], Literal[3], int, Literal[False], Literal[False], Literal[False]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CDoubleTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CDoubleTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex128], int, complex, Literal[False], Literal[True], Literal[True]]

class torchwrench.types.tensor_subclasses.CDoubleTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CDoubleTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex128], Literal[0], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CDoubleTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CDoubleTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex128], Literal[1], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CDoubleTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CDoubleTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex128], Literal[2], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CDoubleTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CDoubleTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex128], Literal[3], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CFloatTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CFloatTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex64], int, complex, Literal[False], Literal[True], Literal[True]]

class torchwrench.types.tensor_subclasses.CFloatTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CFloatTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex64], Literal[0], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CFloatTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CFloatTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex64], Literal[1], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CFloatTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CFloatTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex64], Literal[2], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CFloatTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CFloatTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex64], Literal[3], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CHalfTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CHalfTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex32], int, complex, Literal[False], Literal[True], Literal[True]]

class torchwrench.types.tensor_subclasses.CHalfTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CHalfTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex32], Literal[0], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CHalfTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CHalfTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex32], Literal[1], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CHalfTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CHalfTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex32], Literal[2], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CHalfTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CHalfTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[complex32], Literal[3], complex, Literal[False], Literal[True], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CharTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CharTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int8], int, int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.CharTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CharTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int8], Literal[0], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CharTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CharTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int8], Literal[1], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CharTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CharTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int8], Literal[2], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.CharTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.CharTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int8], Literal[3], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ComplexFloatingTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ComplexFloatingTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], int, complex, Literal[False], Literal[True], Literal[True]]

Intermediate class for checking and typing complex-valued tensors. - Concrete subclasses are: CFloatTensor, CHalfTensor, CDoubleTensor. - Properties are: is_floating_point=False, is_complex=True, is_signed=True. - By default, instantiate this class will create a CFloatTensor.

class torchwrench.types.tensor_subclasses.ComplexFloatingTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ComplexFloatingTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[0], complex, Literal[False], Literal[True], Literal[True]]

class torchwrench.types.tensor_subclasses.ComplexFloatingTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ComplexFloatingTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[1], complex, Literal[False], Literal[True], Literal[True]]

class torchwrench.types.tensor_subclasses.ComplexFloatingTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ComplexFloatingTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[2], complex, Literal[False], Literal[True], Literal[True]]

class torchwrench.types.tensor_subclasses.ComplexFloatingTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ComplexFloatingTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[3], complex, Literal[False], Literal[True], Literal[True]]

class torchwrench.types.tensor_subclasses.DoubleTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.DoubleTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float64], int, float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.DoubleTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.DoubleTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float64], Literal[0], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.DoubleTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.DoubleTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float64], Literal[1], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.DoubleTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.DoubleTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float64], Literal[2], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.DoubleTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.DoubleTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float64], Literal[3], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.FloatTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float32], int, float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.FloatTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float32], Literal[0], float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.FloatTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float32], Literal[1], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.FloatTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float32], Literal[2], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.FloatTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float32], Literal[3], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.FloatingTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatingTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], int, float, Literal[True], Literal[False], Literal[True]]

Intermediate class for checking and typing floating-point tensors. - Concrete subclasses are: FloatTensor, HalfTensor, DoubleTensor. - Properties are: is_floating_point=True, is_complex=False, is_signed=True. - By default, instantiate this class will create a FloatTensor.

class torchwrench.types.tensor_subclasses.FloatingTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatingTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[0], float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.FloatingTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatingTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[1], float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.FloatingTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatingTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[2], float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.FloatingTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.FloatingTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[3], float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.HalfTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.HalfTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float16], int, float, Literal[True], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.HalfTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.HalfTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float16], Literal[0], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.HalfTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.HalfTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float16], Literal[1], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.HalfTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.HalfTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float16], Literal[2], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.HalfTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.HalfTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[float16], Literal[3], float, Literal[True], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.IntTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int32], int, int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.IntTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int32], Literal[0], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.IntTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int32], Literal[1], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.IntTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int32], Literal[2], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.IntTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int32], Literal[3], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.IntegralTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntegralTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], int, int, Literal[False], Literal[False], bool]

Intermediate class for checking and typing integer data type (integer-like) tensors. - Concrete subclasses are: CharTensor, ShortTensor, IntTensor, LongTensor, BoolTensor, ByteTensor. - Properties are: is_floating_point=False, is_complex=False. - By default, instantiate this class will create an LongTensor. - BoolTensor is a subclass of UnsignedIntegerTensor.

class torchwrench.types.tensor_subclasses.IntegralTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntegralTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[0], int, Literal[False], Literal[False], bool]

class torchwrench.types.tensor_subclasses.IntegralTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntegralTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[1], int, Literal[False], Literal[False], bool]

class torchwrench.types.tensor_subclasses.IntegralTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntegralTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[2], int, Literal[False], Literal[False], bool]

class torchwrench.types.tensor_subclasses.IntegralTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.IntegralTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[3], int, Literal[False], Literal[False], bool]

class torchwrench.types.tensor_subclasses.LongTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.LongTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int64], int, int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.LongTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.LongTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int64], Literal[0], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.LongTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.LongTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int64], Literal[1], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.LongTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.LongTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int64], Literal[2], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.LongTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.LongTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int64], Literal[3], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.RealTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.RealTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], int, int, bool, Literal[False], bool]

Intermediate class for checking and typing real data type (non complex) tensors. - Concrete subclasses are: HalfTensor, FloatTensor, DoubleTensor, CharTensor, ShortTensor, IntTensor, LongTensor, BoolTensor, ByteTensor. - Properties are: is_complex=False. - By default, instantiate this class will create an FloatTensor.

class torchwrench.types.tensor_subclasses.RealTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.RealTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[0], int, bool, Literal[False], bool]

class torchwrench.types.tensor_subclasses.RealTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.RealTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[1], int, bool, Literal[False], bool]

class torchwrench.types.tensor_subclasses.RealTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.RealTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[2], int, bool, Literal[False], bool]

class torchwrench.types.tensor_subclasses.RealTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.RealTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[3], int, bool, Literal[False], bool]

class torchwrench.types.tensor_subclasses.ShortTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ShortTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int16], int, int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.ShortTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ShortTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int16], Literal[0], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ShortTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ShortTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int16], Literal[1], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ShortTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ShortTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int16], Literal[2], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.ShortTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.ShortTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[int16], Literal[3], int, Literal[False], Literal[False], Literal[True]]

tolist() → list or number[source]

Returns the tensor as a (nested) list. For scalars, a standard Python number is returned, just like with item(). Tensors are automatically moved to the CPU first if necessary.

This operation is not differentiable.

Examples:

>>> a = torch.randn(2, 2)
>>> a.tolist()
[[0.012766935862600803, 0.5415473580360413],
 [-0.08909505605697632, 0.7729271650314331]]
>>> a[0,0].tolist()
0.012766935862600803
class torchwrench.types.tensor_subclasses.SignedIntegerTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.SignedIntegerTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], int, int, Literal[False], Literal[False], Literal[True]]

Intermediate class for checking and typing signed integer data type (integer-like) tensors. - Concrete subclasses are: IntTensor, LongTensor, ShortTensor. - Properties are: is_floating_point=False, is_complex=False, is_signed=True. - By default, instantiate this class will create an IntTensor. - BoolTensor is not a subclass of SignedIntegerTensor because it is not signed.

class torchwrench.types.tensor_subclasses.SignedIntegerTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.SignedIntegerTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[0], int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.SignedIntegerTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.SignedIntegerTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[1], int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.SignedIntegerTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.SignedIntegerTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[2], int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.SignedIntegerTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.SignedIntegerTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[3], int, Literal[False], Literal[False], Literal[True]]

class torchwrench.types.tensor_subclasses.TTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.TTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], int, bool | int | float | complex, bool, bool, bool]

class torchwrench.types.tensor_subclasses.Tensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.Tensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[0], bool | int | float | complex, bool, bool, bool]

class torchwrench.types.tensor_subclasses.Tensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.Tensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[1], bool | int | float | complex, bool, bool, bool]

class torchwrench.types.tensor_subclasses.Tensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.Tensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[2], bool | int | float | complex, bool, bool, bool]

class torchwrench.types.tensor_subclasses.Tensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.Tensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[3], bool | int | float | complex, bool, bool, bool]

class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], int, int, Literal[False], Literal[False], Literal[False]]

Intermediate class for checking and typing unsigned integer data type (integer-like) tensors. - Concrete subclasses are: BoolTensor, ByteTensor. - Properties are: is_floating_point=False, is_complex=False, is_signed=False. - By default, instantiate this class will create an ByteTensor. - BoolTensor is a subclass of UnsignedIntegerTensor.

class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor0D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor0D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[0], int, Literal[False], Literal[False], Literal[False]]

class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor1D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor1D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[1], int, Literal[False], Literal[False], Literal[False]]

class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor2D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor2D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[2], int, Literal[False], Literal[False], Literal[False]]

class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor3D(*dims: int, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None, memory_format: memory_format | None = None, out: Tensor | None = None, layout: layout | None = None, pin_memory: bool | None = False, requires_grad: bool | None = False)[source]
class torchwrench.types.tensor_subclasses.UnsignedIntegerTensor3D(data: T_BuiltinNumber | Sequence, /, *, dtype: dtype | None | 'default' | str | DTypeEnum = None, device: device | None | 'default' | 'cuda_if_available' | str | int = None)

Bases: _TensorNDBase[Literal[None], Literal[3], int, Literal[False], Literal[False], Literal[False]]