Metadata-Version: 2.1
Name: torch_complex
Version: 0.1.0
Summary: A fugacious python class for PyTorch-ComplexTensor
Home-page: https://github.com/kamo-naoyuki/torch_complex
Author: Naoyuki Kamo
Author-email: naoyuki.kamo829@gmail.com
License: UNKNOWN
Description: # pytorch_complex
        
        [![Build Status](https://travis-ci.org/kamo-naoyuki/pytorch_complex.svg?branch=master)](https://travis-ci.org/kamo-naoyuki/pytorch_complex)
        [![codecov](https://codecov.io/gh/kamo-naoyuki/pytorch_complex/branch/master/graph/badge.svg)](https://codecov.io/gh/kamo-naoyuki/pytorch_complex)
        
        A temporal python class for PyTorch-ComplexTensor
        
        
        ## What is this?
        A Python class to perform as `ComplexTensor` in PyTorch: Nothing except for the following,
        
        ```python
        class ComplexTensor: 
            def __init__(self, ...):
                self.real = torch.Tensor(...)
                self.imag = torch.Tensor(...)
        ```
        
        ### Why?
        PyTorch is great DNN Python library, except that it doesn't support `ComplexTensor` in Python level.
        
        https://github.com/pytorch/pytorch/issues/755
        
        I'm looking forward to the completion, but I need `ComplexTensor` for now.
         I created this cheap module for the temporal replacement of it. Thus, I'll throw away this project as soon as  `ComplexTensor` is completely supported!
        
        ## Requirements
        
        ```
        Python>=3.6
        PyTorch>=1.0
        ```
        
        ## Install
        
        ```
        pip install torch_complex
        ```
        
        ## How to use
        
        ### Basic mathematical operation
        ```python
        import numpy as np
        from torch_complex.tensor import ComplexTensor
        
        real = np.random.randn(3, 10, 10)
        imag = np.random.randn(3, 10, 10)
        
        x = ComplexTensor(real, imag)
        x.numpy()
        
        x + x
        x * x
        x - x
        x / x
        x ** 1.5
        x @ x  # Batch-matmul
        x.conj()
        x.inverse() # Batch-inverse
        ```
        
        All are implemented with combinations of computation of `RealTensor` in python level, thus the speed　is not good enough.
        
        
        ### Functional
        
        ```python
        import torch_complex.functional as F
        F.cat([x, x])
        F.stack([x, x])
        F.matmul(x, x)  # Same as x @ x
        F.einsum('bij,bjk,bkl->bil', [x, x, x])
        ```
        
        ### For DNN
        Almost all methods that `torch.Tensor` has are implemented. 
        
        ```python
        x.cuda()
        x.cpu()
        (x + x).sum().backward()
        ```
        
Platform: UNKNOWN
Classifier: Programming Language :: Python
Classifier: Programming Language :: Python :: 3
Classifier: Programming Language :: Python :: 3.6
Classifier: Programming Language :: Python :: 3.7
Classifier: Programming Language :: Python :: 3.8
Classifier: Development Status :: 5 - Production/Stable
Classifier: Intended Audience :: Science/Research
Classifier: Operating System :: POSIX :: Linux
Classifier: License :: OSI Approved :: Apache Software License
Classifier: Topic :: Software Development :: Libraries :: Python Modules
Description-Content-Type: text/markdown
