Create compute

Author: scraptechguy

compute/__init__.py

@@ -0,0 +1 @@
+./compute_python_wrapper.py

compute/__pycache__/__init__.cpython-311.pyc

@@ -0,0 +1 @@
+/Users/rostislavbroz/Documents/GitHub/tvet/src/Tests/compute.f90

compute/c_compute_module.mod

@@ -0,0 +1,29 @@
+! This automatically generated Fortran wrapper file allows codes
+! written in Fortran to be called directly from C and translates all
+! C-style arguments into expected Fortran-style arguments (with
+! assumed size, local type declarations, etc.).
+
+
+MODULE C_COMPUTE_MODULE
+  IMPLICIT NONE
+
+
+CONTAINS
+
+
+  
+  SUBROUTINE C_COMPUTE1(X_DIM_1, X_DIM_2, X, Y_DIM_1, Y_DIM_2, Y) BIND(C)
+    USE COMPUTE_MODULE, ONLY: COMPUTE1
+    IMPLICIT NONE
+    INTEGER(KIND=SELECTED_INT_KIND(18)), INTENT(IN) :: X_DIM_1
+    INTEGER(KIND=SELECTED_INT_KIND(18)), INTENT(IN) :: X_DIM_2
+    REAL(KIND=KIND ( 0.0D0 )), INTENT(IN), DIMENSION(X_DIM_1,X_DIM_2) :: X
+    INTEGER(KIND=SELECTED_INT_KIND(18)), INTENT(IN) :: Y_DIM_1
+    INTEGER(KIND=SELECTED_INT_KIND(18)), INTENT(IN) :: Y_DIM_2
+    REAL(KIND=KIND ( 0.0D0 )), INTENT(OUT), DIMENSION(Y_DIM_1,Y_DIM_2) :: Y
+  
+    CALL COMPUTE1(X, Y)
+  END SUBROUTINE C_COMPUTE1
+  
+END MODULE C_COMPUTE_MODULE
+

compute/compute.arm64.so

@@ -0,0 +1,98 @@
+'''This Python code is an automatically generated wrapper
+for Fortran code made by 'fmodpy'. The original documentation
+for the Fortran source code follows.
+
+
+'''
+
+import os
+import ctypes
+import platform
+import numpy
+
+# --------------------------------------------------------------------
+#               CONFIGURATION
+# 
+_verbose = True
+_fort_compiler = "gfortran"
+_shared_object_name = "compute." + platform.machine() + ".so"
+_this_directory = os.path.dirname(os.path.abspath(__file__))
+_path_to_lib = os.path.join(_this_directory, _shared_object_name)
+_compile_options = ['-fPIC', '-shared', '-O3']
+_ordered_dependencies = ['compute.f90', 'compute_c_wrapper.f90']
+_symbol_files = []# 
+# --------------------------------------------------------------------
+#               AUTO-COMPILING
+#
+# Try to import the prerequisite symbols for the compiled code.
+for _ in _symbol_files:
+    _ = ctypes.CDLL(os.path.join(_this_directory, _), mode=ctypes.RTLD_GLOBAL)
+# Try to import the existing object. If that fails, recompile and then try.
+try:
+    # Check to see if the source files have been modified and a recompilation is needed.
+    if (max(max([0]+[os.path.getmtime(os.path.realpath(os.path.join(_this_directory,_))) for _ in _symbol_files]),
+            max([0]+[os.path.getmtime(os.path.realpath(os.path.join(_this_directory,_))) for _ in _ordered_dependencies]))
+        > os.path.getmtime(_path_to_lib)):
+        print()
+        print("WARNING: Recompiling because the modification time of a source file is newer than the library.", flush=True)
+        print()
+        if os.path.exists(_path_to_lib):
+            os.remove(_path_to_lib)
+        raise NotImplementedError(f"The newest library code has not been compiled.")
+    # Import the library.
+    clib = ctypes.CDLL(_path_to_lib)
+except:
+    # Remove the shared object if it exists, because it is faulty.
+    if os.path.exists(_shared_object_name):
+        os.remove(_shared_object_name)
+    # Compile a new shared object.
+    _command = " ".join([_fort_compiler] + _compile_options + ["-o", _shared_object_name] + _ordered_dependencies)
+    if _verbose:
+        print("Running system command with arguments")
+        print("  ", _command)
+    # Run the compilation command.
+    import subprocess
+    subprocess.run(_command, shell=True, cwd=_this_directory)
+    # Import the shared object file as a C library with ctypes.
+    clib = ctypes.CDLL(_path_to_lib)
+# --------------------------------------------------------------------
+
+
+class compute_module:
+    ''''''
+
+    
+    # ----------------------------------------------
+    # Wrapper for the Fortran subroutine COMPUTE1
+    
+    def compute1(self, x, y):
+        ''''''
+        
+        # Setting up "x"
+        if ((not issubclass(type(x), numpy.ndarray)) or
+            (not numpy.asarray(x).flags.f_contiguous) or
+            (not (x.dtype == numpy.dtype(ctypes.c_double)))):
+            import warnings
+            warnings.warn("The provided argument 'x' was not an f_contiguous NumPy array of type 'ctypes.c_double' (or equivalent). Automatically converting (probably creating a full copy).")
+            x = numpy.asarray(x, dtype=ctypes.c_double, order='F')
+        x_dim_1 = ctypes.c_long(x.shape[0])
+        x_dim_2 = ctypes.c_long(x.shape[1])
+        
+        # Setting up "y"
+        if ((not issubclass(type(y), numpy.ndarray)) or
+            (not numpy.asarray(y).flags.f_contiguous) or
+            (not (y.dtype == numpy.dtype(ctypes.c_double)))):
+            import warnings
+            warnings.warn("The provided argument 'y' was not an f_contiguous NumPy array of type 'ctypes.c_double' (or equivalent). Automatically converting (probably creating a full copy).")
+            y = numpy.asarray(y, dtype=ctypes.c_double, order='F')
+        y_dim_1 = ctypes.c_long(y.shape[0])
+        y_dim_2 = ctypes.c_long(y.shape[1])
+    
+        # Call C-accessible Fortran wrapper.
+        clib.c_compute1(ctypes.byref(x_dim_1), ctypes.byref(x_dim_2), ctypes.c_void_p(x.ctypes.data), ctypes.byref(y_dim_1), ctypes.byref(y_dim_2), ctypes.c_void_p(y.ctypes.data))
+    
+        # Return final results, 'INTENT(OUT)' arguments only.
+        return y
+
+compute_module = compute_module()
+

compute/compute.f90

@@ -0,0 +1,19 @@
+
+module compute_module
+
+contains
+
+subroutine compute1(x, y)
+
+double precision, dimension(:,:), intent(in) :: x
+double precision, dimension(:,:), intent(out) :: y
+
+y = x**2
+
+print *, "x = ", x
+print *, "y = ", y
+
+return
+end subroutine compute1
+
+end module compute_module