sdot 2024.11.23.0__tar.gz

sdot-2024.11.23.0/PKG-INFO

@@ -0,0 +1,79 @@
+Metadata-Version: 2.3
+Name: sdot
+Version: 2024.11.23.0
+Summary: Tools to construct/handle PowerDiagram, notably for semi-discrete optimal transport
+Keywords: optimal transport,power diagram,Laguerre diagram
+Author-email: Hugo Leclerc <hugo.leclerc@universite-paris-saclay.fr>
+Description-Content-Type: text/markdown
+Requires-Dist: munch
+Requires-Dist: pybind11
+Requires-Dist: archspec
+Requires-Dist: scons
+Requires-Dist: pytest
+Requires-Dist: numpy
+Requires-Dist: matplotlib
+Requires-Dist: dload
+Requires-Dist: gitpython
+
+SDOT
+====
+
+This package contains tool to handle
+* semi-discrete transport plans (between discrete and generic densities),
+* polyhedral convex functions (represented as a max of affine functions),
+* and power diagrams (that can be seen as a generalization of Voronoi diagrams).
+
+It works in any number of dimensions, and is highly optimized, in terms of execution speed and memory usage.
+
+Historically, this package is a re-design of the `pysdot` package, which was written to handle a wide number of semi-discrete transport applications (partial transport, Moreau-Yosida regularization, etc...) but only worked in 2D or 3D. Additionaly, and more specifically, we wanted to make operations on power diagram much more comprehensive and generic.
+
+Currently, there are bindings C++ and Python, but more languages are in the pipeline (feel free to ask if your favorite language is not represented :) ).
+
+Installation
+------------
+
+### Pip
+
+For python, `pip install sdot` should do the job, including some precompiled libraries for the most common cases (2D/3D, float64, ...). If your cases are not included in the distribution, the required dynamic libraries will be automatically compiled on first use. In this situation, you will need to have a C++ compiler installed on your machine. As scons is used to find and call the compiler, all you need to do is install one compiler that is compatible with this builder (for instance g++, clang, xcode, vscode, ...). 
+
+For a compiler : under Debian like, `sudo apt install g++`. Under Mac os, `xcode-select --install`. Under Windows, you can follow [this link](https://code.visualstudio.com/docs/cpp/config-mingw#_prerequisites).
+
+### Sources
+
+To get that latest version, `sdot` can also be installed from the git repository.
+
+For the python modules:
+
+```bash
+git clone https://github.com/sdot-team/sdot.git
+# maybe after a micromamba activate ...
+cd sdot/src/python
+pip install flit
+flit install -s # -s makes symbolic links to the sources
+```
+
+Modules
+-------
+
+* [Optimal transport operations in python](doc/optimal_transport_py.md).
+* [Power or voronoi diagrams and cells in python](doc/power_diagram_py.md).
+* [Polyhedral convex function in python](doc/polyhedral_convex_py.md).
+
+A word on performance
+---------------------
+
+The most common tools to handle voronoi and power diagrams start from delaunay (regular) triangulations. Building this triangulation is generaly the most time-consuming part of this approach, notably because one have to deal with the problems that come with digital precision...
+
+Nevertheless, for most applications of the sdot package, we only need the *integrals* of the cells and the boundaries, meaning that most of the problems with digital precision naturally vanish at the end. We also realized that it was much more convenient for the user to work directly with the cells.
+
+Bearing in mind that exact connectivity may of course be required for some applications (the 'dual' geometry becoming the triangulation in our case :) ), we therefore decided to give a try to algorithms with a focus on the cells, that are computed individually in a fully parallel fashion. We tried to stay on the user specified scalar types (e.g. `float64`) as long as possible. Finally, we designed adapted spatial acceleration structures to stay within O(n log(n)) execution speed with the smallest possible constant.
+
+Internally, it is written in C++/Cuda with SIMD/SIMT instructions. It support large vectors, for out-of-core and multi-machine computations. More on [this page](doc/performance.md).
+
+On going work
+-------------
+
+* pytorch compatible operations
+* pre-guess of the weight to avoid void cells at the beginning
+* non-linear solvers to avoid bad newton directions
+

sdot-2024.11.23.0/README.md

@@ -0,0 +1 @@
+/home/leclerc/sdot/README.md

sdot-2024.11.23.0/pyproject.toml

@@ -0,0 +1,22 @@
+[build-system]
+requires = ["flit_core >=3.2,<4","pytest"]
+build-backend = "flit_core.buildapi"
+
+[project]
+description = "Tools to construct/handle PowerDiagram, notably for semi-discrete optimal transport"
+authors = [ { name = "Hugo Leclerc", email = "hugo.leclerc@universite-paris-saclay.fr" }, ]
+keywords = ["optimal transport","power diagram","Laguerre diagram"]
+dependencies = [ "munch", "pybind11", "archspec", "scons", "pytest", "numpy", "matplotlib", "dload", "gitpython" ]
+version = "2024.11.23.0"
+readme = "README.md"
+name = "sdot"
+
+# Documentation = "https://readthedocs.org"
+# Repository = "https://github.com/me/spam.git"
+
+# [tool.hatch.build.targets.wheel]
+# artifacts = [
+#   "*.so",
+#   "*.dll",
+#   "*.dylib",
+# ]

sdot-2024.11.23.0/sdot/Cell.py

@@ -0,0 +1,272 @@
+from .bindings.integration_module import integration_module
+from .bindings.loader import module_for
+from .Expr import Expr
+
+from types import ModuleType
+import numpy as np
+
+class Cell:
+    """ wrapper around cpp sdot::Cell class """
+
+    def __init__( self, ndim = None, dtype = None, _cell = None, _binding_module = None ):
+        """ _cell is the sdot::Cell class instance. If not specified, __init__ makes a new one using `ndim` and `dtype`.
+            By default, dtype = np.double, ndim = 2
+        """
+
+        if _cell:
+            assert _binding_module is not None
+            self._binding_module = _binding_module
+            self._cell = _cell
+            return
+
+        if ndim is None:
+            ndim = 2
+
+        if dtype is None:
+            dtype = "FP64"
+
+        self._binding_module = module_for( 'sdot', use_arch = True, scalar_type = dtype, nb_dims = ndim )
+        self._cell = self._binding_module.Cell()
+
+    def __repr__( self ):
+        return self._cell.__repr__()
+
+    def integral( self, funcs = '1', underlying_measure_override = None, underlying_radial_function_override = None ):
+        """ integral of a symbolic function or a list of symbolic functions """
+        if not isinstance( funcs, list ):
+            return self.integral( [ funcs ], underlying_measure_override, underlying_radial_function_override )[ 0 ]
+        
+        # module généré
+        module, rt_data = integration_module( funcs, self._binding_module.dtype(), self._binding_module.ndim() )
+        return module.cell_integral( self._cell, rt_data )
+
+    @property
+    def true_dimensionality( self ):
+        """ Size of the base.
+        
+            at the beginning, all the cell starts with true_dimensionality == 0. A first cut will lead to true_dimensionality == 1. 
+            If not in the same direction, true_dimensionality will be incremented, ...
+            If true_dimensionality < ndims, coordinates are expressed in self.base
+        """
+        return self._cell.true_dimensionality()
+
+    @property
+    def vertex_coords_td( self ):
+        """ get list of coordinates for each vertex (stored in a numpy array) in the current base """
+        return self._cell.vertex_coords( True )
+
+    @property
+    def vertex_coords( self ):
+        """ get list of coordinates for each vertex (stored in a numpy array) """
+        return self._cell.vertex_coords( False )
+
+    @property
+    def vertex_refs_td( self ):
+        """ get list of cut indices for each vertex (stored in a numpy array) in the current base """
+        return self._cell.vertex_refs( True )
+
+    @property
+    def vertex_refs( self ):
+        """ get list of cut indices for each vertex (stored in a numpy array) in the current base """
+        return self._cell.vertex_refs( False )
+
+    @property
+    def nb_active_cuts( self ):
+        """ beware: if remove_inactive_cuts() has not been called, this procedure will have first to compute the active cuts (may take some time) """
+        return self._cell.nb_active_cuts()
+
+    @property
+    def nb_stored_cuts( self ):
+        """ may be different from nb_active_cuts if remove_inactive_cuts() has not been called """
+        return self._cell.nb_stored_cuts()
+
+    @property
+    def nb_vertices_td( self ):
+        """ nb vertices in current "true" dimensionality """
+        return self._cell.nb_vertices( True )
+
+    @property
+    def nb_vertices( self ):
+        return self._cell.nb_vertices( False )
+
+    @property
+    def bounded( self ):
+        return self._cell.bounded()
+
+    @property
+    def empty( self ):
+        return self._cell.empty()
+    
+    # @property
+    # def closed_faces( self ):
+    #     return self._cell.closed_faces()
+    
+    @property
+    def base( self ):
+        """ internal base, used to get coordinates and directions if true_dimensionnality < nb_dims.
+            It true_dimensionality == nb_dims, it return an identity matrix
+        """
+        return self._cell.base()
+    
+    @property
+    def ndim( self ):
+        return self._cell.ndim()
+    
+    @property
+    def cuts( self ):
+        return self._cell.cuts()
+    
+    def cut_boundary( self, dir, val, index = 0 ):
+        return self._cell.cut_boundary( np.ascontiguousarray( dir ), val, int( index ) )
+
+    def cut( self, dir, val, index = 0 ):
+        return self._cell.cut( np.ascontiguousarray( dir ), val, int( index ) )
+
+    def display_vtk( self, vtk_output ):
+        return self._cell.display_vtk( vtk_output )
+
+    # def for_each_face( self, on_face ):
+    #     """
+    #         Call args:
+    #             on_face( cut_refs, vertex_indices, ray_refs_list ),
+    #     """
+    #     return self._cell.for_each_face( on_face )
+
+    def for_each_edge( self, on_edge ):
+        """
+            on_edge( edge_refs, vertex_indices )
+                * edge_refs = [ num_cut_0, ... ]
+                * vertex_indices => 
+                   - size = 2 for a regular edge
+                   - size = 1 for a ray
+
+        """
+        return self._cell.for_each_edge( on_edge, False )
+
+    def for_each_edge_td( self, on_edge ):
+        """
+            on_edge( edge_refs, vertex_indices )
+                * edge_refs = [ num_cut_0, ... ]
+                * vertex_indices => 
+                   - size = 2 for a regular edge
+                   - size = 1 for a ray
+
+        """
+        return self._cell.for_each_edge( on_edge, True )
+
+    def ray_dir( self, ray_refs, base_vertex ):
+        return self._cell.ray_dir( ray_refs, base_vertex )
+
+    def plot_pyplot( self, fig, color = 'black', linestyle = '-', linewidth = 2, low_dim_linewidth_coeff = 0.25, ray_length = 0.2, ray_color = None, ray_linestyle = '--', free_color = None, free_linestyle = ':' ):
+        """
+            ray_length is the length used to display infinite edges.
+        """
+
+        # check fig properties
+        if isinstance( fig, ModuleType ):
+            fig.axis( 'equal' )
+
+        if self.ndim == 3:
+            fig = fig.figure()
+            fig = fig.add_subplot( projection = '3d' )
+
+        #
+        coords = self.vertex_coords_td @ self.base
+
+        # find a complementary base
+        cbase = list( np.eye( self.ndim ) )
+        for r in range( self.ndim ):
+            for c in self.base:
+                cbase[ r ] -= np.dot( cbase[ r ], c ) * c
+        cbase.sort( key = np.linalg.norm )
+        cbase = cbase[ self.true_dimensionality : ]
+
+        # helper to plot
+        def pl( array, gtype ):
+            array = np.array( array )
+            xyz = [ array[ :, d ] for d in range( min( self.ndim, 3 ) ) ]
+            kwa = { 'linewidth': linewidth }
+            if self.true_dimensionality < self.ndim and gtype != 'free':
+                kwa[ 'linewidth' ] *= low_dim_linewidth_coeff
+
+            if gtype == 'free':
+                return fig.plot( *xyz, **kwa, linestyle = free_linestyle, color = free_color or color )
+            if gtype == 'ray':
+                return fig.plot( *xyz, **kwa, linestyle = ray_linestyle, color = ray_color or color )
+            if gtype == 'edge':
+                return fig.plot( *xyz, **kwa, linestyle = linestyle, color = color )
+
+        # for each vertex, plot free items, get the edges and the rays
+        for c in coords:
+            for cvec in cbase:
+                pl( [ c - ray_length * cvec, c + ray_length * cvec ], 'free' )
+
+        # plot edge
+        def edge_func( refs, vertices ):
+            if len( refs ) == 0:
+                return
+
+            # ray
+            if len( vertices ) == 1:
+                rd = self.ray_dir( refs, vertices[ 0 ] ) @ self.base
+                rd /= np.linalg.norm( rd )
+                bc = coords[ vertices[ 0 ] ]
+                pl( [ bc, bc + ray_length * rd ], 'ray' )
+                return
+            
+            # edge
+            if len( vertices ) == 2:
+                pl( [ coords[ vertices[ 0 ] ], coords[ vertices[ 1 ] ] ], 'edge' )
+                return
+
+            raise RuntimeError( "not an expected size for vertices" )
+
+        self.for_each_edge_td( edge_func )
+
+    def plot( self, fig = None, **kwargs ):
+        """  
+        """
+        if fig is None:
+            import matplotlib.pyplot as plt
+            self.plot( plt )
+            plt.show()
+            return
+
+        self.plot_pyplot( fig, **kwargs )
+
+        # if self.true_dimensionality == 2:
+
+        #     def disp_ray( ray_refs, vertex_index, rev ):
+        #         print( "ray" )
+        #         dir = self.ray_dir( ray_refs, vertex_index ) @ self.base.T
+        #         b_c = coords[ vertex_index ]
+        #         d_c = b_c + ray_length * dir / np.linalg.norm( dir )
+        #         x = [ b_c[ 0 ], d_c[ 0 ] ]
+        #         y = [ b_c[ 1 ], d_c[ 1 ] ]
+        #         if rev:
+        #             x.reverse()
+        #             y.reverse()
+        #         fig.plot( x, y, ray_linestyle or linestyle, color = ray_color or color )
+
+        #     def on_face( edge_refs, vertex_indices, ray_refs ):
+        #         print( "cut_refs" )
+
+        #         if len( ray_refs ) >= 1:
+        #             disp_ray( ray_refs[ 0 ], vertex_indices[ 0 ], 1 )
+
+        #         if len( vertex_indices ) >= 2:
+        #             x = [ coords[ n, 0 ] for n in vertex_indices ]
+        #             y = [ coords[ n, 1 ] for n in vertex_indices ]
+        #             if len( ray_refs ) == 0: # closed
+        #                 x.append( x[ 0 ] )
+        #                 y.append( y[ 0 ] )
+        #             fig.plot( x, y, linestyle, color = color )
+
+        #         if len( ray_refs ) >= 2:
+        #             disp_ray( ray_refs[ 1 ], vertex_indices[ -1 ], 0 )
+
+        #     self.for_each_face( on_face )
+        #     return
+
+        # raise RuntimeError( f"TODO: plot for dim == { self.ndim }" )
+        

sdot-2024.11.23.0/sdot/ConvexFunction.py

@@ -0,0 +1,199 @@
+from .PowerDiagram import PowerDiagram, rt_int
+import numpy as np
+import vfs
+
+class ConvexFunction:
+    """ 
+        Function =
+          max( 
+            -inf, 
+            scalar_product( m_dirs[ 0 ], y ) - m_offs[ 0 ], 
+            scalar_product( m_dirs[ 1 ], y ) - m_offs[ 1 ], 
+            ...
+          ) 
+          for y such that 
+            scalar_product( b_dirs[ 0 ], y ) - b_offs[ 0 ] <= 0,
+            scalar_product( b_dirs[ 1 ], y ) - b_offs[ 1 ] <= 0,
+            ...
+    """
+
+    def __init__( self, m_dirs, m_offs, b_dirs = None, b_offs = None, dtype = np.double ) -> None:
+        # m_...
+        self.m_dirs = np.asarray( m_dirs, dtype = dtype )
+        self.m_offs = np.asarray( m_offs, dtype = dtype )
+
+        assert( self.m_dirs.ndim == 2 )
+        assert( self.m_offs.ndim == 1 )
+        assert( self.m_offs.shape[ 0 ] == self.m_dirs.shape[ 0 ] )
+
+        # b_...
+        if b_dirs is None or not len( b_dirs ):
+            assert( b_offs is None or not len( b_offs ) )
+            b_dirs = np.zeros( [ 0, self.m_dirs.shape[ 1 ] ], dtype = dtype )
+            b_offs = np.zeros( [ 0 ], dtype = dtype )
+        self.b_dirs = np.asarray( b_dirs, dtype = dtype )
+        self.b_offs = np.asarray( b_offs, dtype = dtype )
+
+        assert( self.b_dirs.ndim == 2 )
+        assert( self.b_offs.ndim == 1 )
+        assert( self.b_offs.shape[ 0 ] == self.b_dirs.shape[ 0 ] )
+        assert( self.b_dirs.shape[ 1 ] == self.m_dirs.shape[ 1 ] )
+
+        # attributes by deduction
+        self.nb_dims = self.m_dirs.shape[ 1 ]
+
+    def make_approx_from_values_and_derivatives( sample_coords, f_val, f_der, b_dirs = None, b_offs = None ):
+        m_dirs = []
+        m_offs = []
+        for num_point in range( sample_coords.shape[ 1 ] ):
+            point = sample_coords[ :, num_point ]
+            val = f_val( point )
+            der = f_der( point )
+
+            m_dirs.append( der )
+            m_offs.append( np.dot( der, point ) - val )
+        return ConvexFunction( m_dirs, m_offs, b_dirs, b_offs )
+
+    def to_power_diagram( self ):
+        weights = np.sum( self.m_dirs * self.m_dirs, axis = 1 ) - 2 * self.m_offs
+        return PowerDiagram( self.m_dirs, weights, self.b_dirs, self.b_offs )
+
+    def write_vtk( self, filename, fit_boundary = 1.0 ):
+        pd = self.to_power_diagram()
+        pd.write_vtk( filename, fit_boundary )
+
+    def summary( self ):
+        from sympy import Symbol, tensorproduct
+
+        y = [ Symbol( f'y_{ d }' ) for d in range( self.nb_dims ) ]
+
+        repr_max = lambda i: str( sum( tensorproduct( self.m_dirs[ i, : ], y ) ) -  self.m_offs[ i ] )
+        repr_bnd = lambda i: str( sum( tensorproduct( self.b_dirs[ i, : ], y ) ) <= self.b_offs[ i ] )
+
+        lst_max = [ repr_max( i ) for i in range( self.m_dirs.shape[ 0 ] ) ]
+        lst_bnd = [ repr_bnd( i ) for i in range( self.b_dirs.shape[ 0 ] ) ]
+        lst_max.sort()
+        lst_bnd.sort()
+
+        res = f"max({ ', '.join( lst_max ) })"
+        if len( lst_bnd ):
+            res += f" for { ', '.join( lst_bnd ) }"
+        return res
+
+    def legendre_transform( self ):
+        # call the legendre_transform func
+        func = vfs.function( 'legendre_transform', [ f'inc_file:sdot/legendre_transform/legendre_transform.h' ] )
+        new_m_dirs, new_m_offs, new_b_dirs, new_b_offs = func( self.m_dirs, self.m_offs, self.b_dirs, self.b_offs, rt_int( self.nb_dims ) )
+        new_m_dirs = np.reshape( new_m_dirs, [ -1, self.nb_dims ] )
+        new_b_dirs = np.reshape( new_b_dirs, [ -1, self.nb_dims ] )
+
+        # make a new ConvexFunction
+        return ConvexFunction( new_m_dirs, new_m_offs, new_b_dirs, new_b_offs )
+
+    def __repr__( self ):
+        return self.summary()
+
+    def is_inside_boundaries( self, x_k ):
+        if isinstance( x_k, ( int, float ) ):
+            x_k = [ x_k ]
+        x_k = np.asarray( x_k )
+
+        return self.b_dirs.shape[ 0 ] == 0 or ( self.b_dirs @ x_k - self.b_offs ).max() <= 0
+
+    def __call__( self, x_k ):
+        return self.val( x_k )
+    
+    def val( self, x_k ):
+        if isinstance( x_k, ( int, float ) ):
+            x_k = [ x_k ]
+        x_k = np.asarray( x_k )
+
+        if not self.is_inside_boundaries( x_k ):
+            return float('inf')
+        
+        return ( self.m_dirs @ x_k - self.m_offs ).max()
+
+    def grad( self, x_k ):
+        if isinstance( x_k, ( int, float ) ):
+            x_k = [ x_k ]
+        x_k = np.asarray( x_k )
+
+        if not self.is_inside_boundaries( x_k ):
+            return float('inf')
+
+        k = ( self.m_dirs @ x_k - self.m_offs ).argmax()     
+        return self.m_dirs[ k ]
+
+    def __add__( self, u2 ):
+        u1 = self
+        if isinstance( u2, ConvexFunction ): # addition of two convex functions
+            if u1.nb_dims == u2.nb_dims:
+                nb_dims = u1.nb_dims
+            else:
+                print('Dimensions do not match.')
+
+            new_m_dirs = ( u1.m_dirs[ :, None, : ] + u2.m_dirs[ None, :, : ] ).reshape( ( -1, nb_dims ) )
+            new_m_offs = ( u1.m_dirs[ :, None ] + u2.m_dirs[ None, : ] ).flatten()
+            new_b_dirs = np.block( [ [ u1.b_dirs ], [ u2.b_dirs ] ] )
+            new_b_offs = np.concatenate( [ u1.b_offs, u2.b_offs ] )
+
+            return ConvexFunction( new_m_dirs, new_m_offs, new_b_dirs, new_b_offs )
+            
+        elif isinstance( u2, ( int, float ) ): # addition of a polyhedral function and a scalar
+            return ConvexFunction( u1.m_dirs, u1.m_offs - u2, u1.b_dirs, u1.b_offs )
+        
+        else:
+            raise NotImplementedError( "Can't add Polyhedral and {}".format( type( u2 ) ) )
+        
+    def __radd__( self, scal ):
+        return self.__add__( scal )
+    
+    def __sub__( self, scal ):
+        if isinstance( scal,( int, float ) ): 
+            return ConvexFunction( self.m_dirs, self.m_offs + scal, self.b_dirs, self.b_offs )
+        else:
+            raise NotImplementedError( "Can't substract ConvexFunction from {}".format( type( scal ) ) )
+    
+    def __mul__( self, scal ):
+        if isinstance( scal, ( int, float ) ): 
+            assert( scal >= 0 )
+            return ConvexFunction( scal * self.m_dirs, scal * self.m_offs, self.b_dirs, self.b_offs )
+        else:
+            raise NotImplementedError( "Can't multiply ConvexFunction and {}".format( type( scal ) ) )
+            
+    def __rmul__( self, scal ):
+        return self.__mul__( scal )
+        
+    def __truediv__( self, scal ):
+        if isinstance( scal, ( int, float ) ): 
+            assert( scal > 0 )
+            return ConvexFunction( self.m_dirs / scal, self.m_offs / scal, self.b_dirs, self.b_offs )
+        else:
+            raise NotImplementedError( "Can't divide {} by ConvexFunction.".format( type( scal ) ) )
+
+
+    def __or__(self,u2): 
+        u1 = self
+        if isinstance( u2, ConvexFunction ): # maximum of two PHC functions
+            new_m_dirs = np.block( [ [ u1.m_dirs ], [ u2.m_dirs ] ] )
+            new_m_offs = np.concatenate( [ u1.m_offs, u2.m_offs ] )
+            new_b_dirs = np.block( [ [ u1.b_dirs ], [ u2.b_dirs ] ] )
+            new_b_offs = np.concatenate( [ u1.b_offs,u2.b_offs ] )
+            return ConvexFunction( new_m_dirs, new_m_offs, new_b_dirs, new_b_offs )
+            
+        elif isinstance(u2,(int,float)): # addition of a polyhedral function and a scalar
+            return u1.__or__( ConvexFunction( np.zero( [ 1, u1.nb_dims ] ), [ -u2 ] ) )
+        
+        else:
+            raise NotImplementedError( "Can't take the maximum of ConvexFunction and {}".format( type( u2 ) ) )
+        
+    def __ror__( self, scal ):
+        return self.__or__( scal )
+
+
+    def __xor__( self, u2 ): # inf-convolution of two PHC functions
+        if isinstance( u2, ConvexFunction ):
+            return ( self.legendre_transform() + u2.legendre_transform() ).legendre_transform()
+            
+        else:
+            raise NotImplementedError("Can't take the inf-convolution of ConvexFunction and {}".format(type(u2)))

sdot-2024.11.23.0/sdot/D2GTransportMap.py

@@ -0,0 +1,5 @@
+class D2GTransportMap:
+    """
+        Discrete (diracs) to generic measure transport map (optimal or not)
+    """
+