torchwrench.types package

class torchwrench.types.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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.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]]

torchwrench.types.is_builtin_number(x: Any, *, strict: bool = False) → TypeIs[bool | int | float | complex][source]

Returns True if x is an instance of a builtin number type (int, float, bool, complex).

Args:

x: Object to check. strict: If True, it will not consider custom subtypes of builtins as builtin numbers. defaults to False.

torchwrench.types.is_builtin_scalar(x: Any, *, strict: bool = False) → TypeIs[bool | int | float | complex | None | str | bytes][source]

Returns True if x is an instance of a builtin scalar type (int, float, bool, complex, NoneType, str, bytes).

Args:

x: Object to check. strict: If True, it will not consider subtypes of builtins as builtin scalars. defaults to False.

torchwrench.types.is_integral_dtype(dtype: dtype | None | 'default' | str | DTypeEnum) → bool[source]
torchwrench.types.is_number_like(x: Any) → TypeGuard[bool | int | float | complex | ndarray | number | Tensor0D][source]

Returns True if input is a scalar number.

Accepted numbers-like objects are: - Python numbers (int, float, bool, complex) - Numpy zero-dimensional arrays - Numpy numbers - PyTorch zero-dimensional tensors

torchwrench.types.is_numpy_number_like(x: Any) → TypeGuard[ndarray | number][source]

Returns True if x is an instance of a numpy number type, a np.bool_ or a zero-dimensional numpy array. If numpy is not installed, this function always returns False.

torchwrench.types.is_numpy_scalar_like(x: Any) → TypeGuard[ndarray | generic][source]

Returns True if x is an instance of a numpy number type or a zero-dimensional numpy array. If numpy is not installed, this function always returns False.

torchwrench.types.is_scalar_like(x: Any) → TypeGuard[bool | int | float | complex | None | str | bytes | ndarray | generic | Tensor0D][source]

Returns True if input is a scalar number.

Accepted scalar-like objects are: - Python scalars like (int, float, bool, complex, None, str, bytes) - Numpy zero-dimensional arrays - Numpy generic - PyTorch zero-dimensional tensors

torchwrench.types.is_tensor_or_array(x: Any) → TypeIs[Tensor | ndarray][source]

Submodules