v2.0.1 Replace cppEDM with numpy/scipy

Author: SoftwareLiteracy

.gitignore

@@ -1,4 +1,5 @@
+etc
 __pycache__
-cppEDM/lib/
-pyEDM/__pycache__
-pyEDM/tests/__pycache__
+src/pyEDM.egg-info
+src/pyEDM/__pycache__
+src/pyEDM/tests/__pycache__

CITATION.cff

@@ -1,19 +1,13 @@
 cff-version: 1.2.0
 title: pyEDM
 message: >-
-  If you use this software please cite. Licensed by the
-  University of California for educational, research and
-  non-profit purposes.
+  If you use this software please cite.
 type: software
 authors:
   - given-names: Joseph
     family-names: Park
     email: [email protected]
     orcid: 'https://orcid.org/0000-0001-5411-1409'
-  - given-names: Cameron
-    family-names: Smith
-    orcid: 'https://orcid.org/0000-0003-0020-5607'
-    email: [email protected]
   - {}
 identifiers:
   - type: url
@@ -22,5 +16,5 @@ repository-code: 'https://github.com/SugiharaLab/pyEDM'
 url: 'https://github.com/SugiharaLab/pyEDM#readme'
 repository: 'https://pypi.org/project/pyEDM/'
 abstract: >-
-  Python wrapper of C++ EDM tools. UCSD Scripps Institution
-  of Oceanography, Sugihara Lab.
+  Python implementation of EDM tools developed at the
+  Sugihara Lab, UCSD Scripps Institution of Oceanography.

MANIFEST.in

@@ -1,2 +1,3 @@
-include cppEDM/src/*
-include src/bindings/*
+include src/pyEDM/data/*.csv
+include src/pyEDM/tests/*.py
+include src/pyEDM/tests/validation/*.csv

README.md

@@ -1,6 +1,6 @@
 ## Empirical Dynamic Modeling (EDM)
 ---
-This package provides a Python/Pandas DataFrame interface to the [cppEDM](https://github.com/SugiharaLab/cppEDM "cppEDM") library for [EDM analysis](http://deepeco.ucsd.edu/nonlinear-dynamics-research/edm/ "EDM @ Sugihara Lab").  Introduction and documentation are are avilable [online](https://sugiharalab.github.io/EDM_Documentation/ "EDM Docs"), or in the package [API docs](https://github.com/SugiharaLab/pyEDM/blob/master/doc/pyEDM.pdf "pyEDM API"). A Jupyter notebook interface is available at [jpyEDM](https://github.com/SugiharaLab/jpyEDM#empirical-dynamic-modeling-edm-jupyter-notebook).
+This package provides a Python/Pandas DataFrame toolset for [EDM analysis](http://deepeco.ucsd.edu/nonlinear-dynamics-research/edm/ "EDM @ Sugihara Lab").  Introduction and documentation are are avilable [online](https://sugiharalab.github.io/EDM_Documentation/ "EDM Docs"), or in the package [API docs](https://github.com/SugiharaLab/pyEDM/blob/master/doc/pyEDM.pdf "pyEDM API"). A Jupyter notebook interface is available at [jpyEDM](https://github.com/SugiharaLab/jpyEDM#empirical-dynamic-modeling-edm-jupyter-notebook).
 
 Functionality includes:
 * Simplex projection ([Sugihara and May 1990](https://www.nature.com/articles/344734a0))
@@ -13,32 +13,11 @@ Functionality includes:
 ## Installation
 
 ### Python Package Index (PyPI)
-Certain MacOS, Linux and Windows platforms are supported with prebuilt binary distributions hosted on PyPI [pyEDM](https://pypi.org/project/pyEDM/). 
-
-Command line using the Python pip module: `python -m pip install pyEDM`
-
-### Manual Install
-If a pre-built binary distribution is not available the user can build the cppEDM library, then install the Python package using pip. On OSX and Linux this requires g++. On Windows, the mingw-w64 GCC is available as in [MSYS2](https://www.msys2.org/).
-
-Note the [LAPACK](http://www.netlib.org/lapack/explore-html/index.html) library is required to build cppEDM and pyEDM. As of version 1.15.1, LAPACK is not required on Windows.
-
-#### OSX and Linux
-1. Download pyEDM: `git clone https://github.com/SugiharaLab/pyEDM`
-2. Build cppEDM library: `cd pyEDM/cppEDM/src; make`
-3. Build and install package: `cd ../..; python -m pip install . --user`
-
-#### Windows
-0. If a Windows binary is not available, these suggestions may be useful.
-1. mingw-w64 GCC is available in [MSYS2](https://www.msys2.org/).
-2. Prior to version 1.15.1, [gfortran](https://gcc.gnu.org/wiki/GFortranBinariesWindows) and [OpenBLAS](https://www.openblas.net/) libraries are required.
-3. Download pyEDM: `git clone https://github.com/SugiharaLab/pyEDM`
-4. Build cppEDM library: `cd pyEDM\cppEDM\src; make`
-5. Adjust paths to find gfortran and openblas libraries (pyEDM/pyEDM/etc/windows/libopenblas.a). You may need to rename libEDM.a to EDM.lib, and openblas.a to openblas.lib.
-6. Build and install package in `pyEDM\`: `python -m pip install . --user`
+Certain MacOS, Linux and Windows platforms are supported with prebuilt binary distributions hosted on PyPI [pyEDM](https://pypi.org/project/pyEDM/) and can be installed with the Python pip module: `python -m pip install pyEDM`
 
 ---
 ## Usage
-Example usage at the python prompt:
+Examples can be executed in the python command line:
 ```python
 >>> import pyEDM
 >>> pyEDM.Examples()

pyEDM/etc/apps/.gitignore apps/.gitignore

@@ -5,21 +5,21 @@
 from   itertools       import repeat
 
 from pandas import DataFrame, read_csv, concat
-from pyEDM  import EmbedDimension, sampleData
+from pyEDM  import Simplex, sampleData
 from matplotlib import pyplot as plt
 
 #----------------------------------------------------------------------------
 # 
 #----------------------------------------------------------------------------
-def EmbedDim_Columns( data, target = None, maxE = 20,
+def CrossMap_Columns( data, target = None, E = 0,
                       Tp = 1, tau = -1, exclusionRadius = 0,
-                      lib = None, pred = None, numThreads = 4, cores = 5,
+                      lib = None, pred = None, cores = 5,
                       outputFile = None, noTime = False,
                       verbose = False, plot = False ):
 
-    '''Use multiprocessing Pool to process parallelise EmbedDimension.
+    '''Use multiprocessing Pool to process parallelise Simplex.
        The target (-t) argument specifies a column against which all
-       other columns will be cross mapped.
+       other columns are cross mapped.
     '''
 
     startTime = time.time()
@@ -37,69 +37,62 @@ def EmbedDim_Columns( data, target = None, maxE = 20,
     if not noTime :
         columns = data.columns[ 1 : len(data.columns) ].to_list()
 
-    # Dictionary of arguments for Pool : EmbedDimFunc
-    argsD = { 'lib' : lib, 'pred' : pred, 'maxE' : maxE,
+    # Dictionary of arguments for Pool : SimplexFunc
+    argsD = { 'lib' : lib, 'pred' : pred, 'E' : E,
               'exclusionRadius' : exclusionRadius, 'Tp' : Tp,
-              'tau' : tau, 'target' : target,
-              'numThreads' : numThreads, 'noTime' : noTime }
+              'tau' : tau, 'target' : target, 'noTime' : noTime }
 
     # Create iterable for Pool.starmap, use repeated copies of argsD, data
     poolArgs = zip( columns, repeat( argsD ), repeat( data ) )
 
     # Use pool.starmap to distribute among cores
-    pool = Pool( processes = cores )
-    
-    # starmap: elements of the iterable argument are iterables
-    #          that are unpacked as arguments
-    EDList = pool.starmap( EmbedDimFunc, poolArgs )
+    with Pool( processes = cores ) as pool :
+        CMList = pool.starmap( SimplexFunc, poolArgs )
 
-    # Load EDList results into dictionary : DataFrame
+    # Load CMList results into dictionary
     D = {}
-    D[ 'E' ] = EDList[0]['E'].astype( int )
     for i in range( len( columns ) ) :
-        D[ f'{columns[i]}:{target}' ] = EDList[ i ]['rho']
-
-    df = DataFrame( D )
+        D[ f'{columns[i]}:{target}' ] = CMList[ i ]
 
     print( "Elapsed time:", round( time.time() - startTime, 2 ) )
 
     if verbose :
-        print( df )
+        print( D.keys() )
 
     if plot :
-        df.plot( 'E', df.columns[1:], linewidth = 3,
-                 ylabel = 'Prediction ρ'  )
+        df = D[ list( D.keys() )[-1] ]
+        df.plot( df.columns[0], df.columns[1:3], linewidth = 3,
+                 ylabel = list( D.keys() )[-1] )
         plt.show()
 
     if outputFile :
         df.to_csv( outputFile )
 
-    return df
+    return D
 
 #----------------------------------------------------------------------------
 #----------------------------------------------------------------------------
-def EmbedDimFunc( column, argsD, data ):
+def SimplexFunc( column, argsD, data ):
     '''Call pyEDM EmbedDimension using the column, args, and data'''
 
-    ed = EmbedDimension( dataFrame       = data,
-                         lib             = argsD['lib'],
-                         pred            = argsD['pred'],
-                         maxE            = argsD['maxE'],
-                         exclusionRadius = argsD['exclusionRadius'],
-                         Tp              = argsD['Tp'],
-                         tau             = argsD['tau'],
-                         columns         = column,
-                         target          = argsD['target'],
-                         numThreads      = argsD['numThreads'],
-                         noTime          = argsD['noTime'],
-                         showPlot        = False )
-
-    return ed
+    df = Simplex( dataFrame       = data,
+                  columns         = column,
+                  target          = argsD['target'],
+                  lib             = argsD['lib'],
+                  pred            = argsD['pred'],
+                  E               = argsD['E'],
+                  exclusionRadius = argsD['exclusionRadius'],
+                  Tp              = argsD['Tp'],
+                  tau             = argsD['tau'],
+                  noTime          = argsD['noTime'],
+                  showPlot        = False )
+
+    return df
 
 #----------------------------------------------------------------------------
 #----------------------------------------------------------------------------
-def EmbedDim_Columns_CmdLine():
-    '''Wrapper for EmbedDim_Columns with command line parsing'''
+def CrossMap_Columns_CmdLine():
+    '''Wrapper for CrossMap_Columns with command line parsing'''
 
     args = ParseCmdLine()
 
@@ -112,20 +105,20 @@ def EmbedDim_Columns_CmdLine():
     else:
         raise RuntimeError( "Invalid inputFile or inputData" )
 
-    # Call EmbedDim_Columns()
-    df = EmbedDim_Columns( data = dataFrame, target = args.target,
-                           maxE = args.maxE, Tp = args.Tp, tau = args.tau,
+    # Call CrossMap_Columns()
+    df = CrossMap_Columns( data = dataFrame, target = args.target,
+                           E = args.E, Tp = args.Tp, tau = args.tau,
                            exclusionRadius = args.exclusionRadius,
                            lib = args.lib, pred = args.pred,
-                           numThreads = args.numThreads, cores = args.cores,
-                           outputFile = args.outputFile, noTime = args.noTime,
+                           cores = args.cores, noTime = args.noTime,
+                           outputFile = args.outputFile,
                            verbose = args.verbose, plot = args.Plot )
 
 #----------------------------------------------------------------------------
 #----------------------------------------------------------------------------
 def ParseCmdLine():
 
-    parser = argparse.ArgumentParser( description = 'EmbedDimension MultiProc' )
+    parser = argparse.ArgumentParser( description = 'CrossMap Columns' )
 
     parser.add_argument('-i', '--inputFile',
                         dest    = 'inputFile', type = str, 
@@ -145,11 +138,11 @@ def ParseCmdLine():
                         default = None,
                         help    = 'Output file.')
 
-    parser.add_argument('-E', '--maxE',
-                        dest    = 'maxE', type = int, 
+    parser.add_argument('-E', '--E',
+                        dest    = 'E', type = int, 
                         action  = 'store',
-                        default = 20,
-                        help    = 'Maximum embedding dimension.')
+                        default = 0,
+                        help    = 'E.')
 
     parser.add_argument('-x', '--exclusionRadius',
                         dest    = 'exclusionRadius', type = int, 
@@ -187,12 +180,6 @@ def ParseCmdLine():
                         default = [],
                         help    = 'prediction indices.')
 
-    parser.add_argument('-n', '--numThreads',
-                        dest    = 'numThreads', type = int, 
-                        action  = 'store',
-                        default = 3,
-                        help    = 'EmbedDimension numThreads.')
-
     parser.add_argument('-C', '--cores',
                         dest    = 'cores', type = int, 
                         action  = 'store',
@@ -224,4 +211,4 @@ def ParseCmdLine():
 #----------------------------------------------------------------------------
 # Provide for cmd line invocation and clean module loading
 if __name__ == "__main__":
-    EmbedDim_Columns_CmdLine()
+    CrossMap_Columns_CmdLine()