Updated elgohr/Publish-Docker-Github-Action to a supported version (v5)

.github/workflows/build.yml

@@ -26,4 +26,4 @@ jobs:
           HOME: /root
         run:  |
           . "$HOME/.cargo/env"
-          scons -Q
+          scons -Q --random -j2

.github/workflows/publish_container.yml

@@ -10,7 +10,7 @@ jobs:
     steps:
     - uses: actions/checkout@master
     - name: Publish to Registry
-      uses: elgohr/Publish-Docker-Github-Action@master
+      uses: elgohr/Publish-Docker-Github-Action@v5
       with:
         name: algorithm-archivists/aaa-langs
         username: ${{ github.actor }}

.gitignore

@@ -478,7 +478,7 @@ paket-files/
 # Python Tools for Visual Studio (PTVS)
 __pycache__/
 *.pyc
-
+*.ipynb_checkpoints*
 # Cake - Uncomment if you are using it
 # tools/**
 # !tools/packages.config

CONTRIBUTORS.md

@@ -61,4 +61,6 @@ This file lists everyone, who contributed to this repo and wanted to show up her
 - Hugo Salou
 - Dimitri Belopopsky
 - Henrik Abel Christensen
+- K. Shudipto Amin
 - Peanutbutter_Warrior
+- Thijs Raymakers 

SConstruct

@@ -8,63 +8,128 @@ Currently, the aim is to provide a way to compile or copy the implementation fil
 To run the compilation for all implementations in one language, e.g. C, run the command `scons build/c`, and the resulting executables will be available in the `build/c` directory, each in their respective algorithm directory, containing the executable."""
 
 from pathlib import Path
+from collections import namedtuple
 import os
 
-rust_cargo_builder = Builder(action=['cargo build --bins --manifest-path $MANIFEST',
-                                     Move('$TARGET$PROGSUFFIX', '$SOURCE_DIR/target/debug/main$PROGSUFFIX')])
+import SCons
+SCons.Warnings.warningAsException()
 
-rust_rustc_builder = Builder(action='rustc $SOURCE -o $TARGET$PROGSUFFIX')
-
-go_builder = Builder(action='go build -o $TARGET$PROGSUFFIX $SOURCE')
+# For interpreted languages to copy to build directory
+copy_builder = Builder(action=Copy('$TARGET', '$SOURCE'))
 
 env = Environment(ENV=os.environ,
-                  BUILDERS={'rustc': rust_rustc_builder,
-                            'cargo': rust_cargo_builder,
-                            'Go': go_builder},
-                  tools=['gcc', 'gnulink', 'g++', 'gas', 'gfortran'])
+                  BUILDERS={'Copier': copy_builder}, 
+                  tools=[
+                    'g++', 'gas', 'gcc', 'gfortran', 'gnulink', 'javac'],
+                  toolpath=['builders'])
+
+available_languages = {
+    'asm-x64',
+    'bash',
+    'c',
+    'cpp',
+    'fortran',
+    'java',
+    'julia',
+    'lolcode'
+    'lua',
+    'php',
+    'powershell',
+    'python',
+    'ruby',
+    'viml',
+}
+
+languages_to_import = {
+    'coconut': ['coconut'],
+    'go': ['go'],
+    'rust': ['rustc', 'cargo'],
+    'kotlin': ['kotlin'],
+}
+
+for language, tools in languages_to_import.items():
+    for tool in tools:
+        try:
+            env.Tool(tool)
+        except SCons.Warnings.SConsWarning as w:
+            print(f'{w.args[0][0]}, ignoring')
+            break
+    else:
+        available_languages.add(language)
+
+
+Export('env')
 
-env['CFLAGS'] = '-Wall -Wextra -Werror'
-env['CXXFLAGS'] = '-std=c++17'
+env['CCFLAGS'] = '-Wall -Wextra -Werror -pedantic -Wconversion'
+env['CFLAGS'] = '-std=gnu99'
+env['CXXFLAGS'] = '-std=c++17 -Wold-style-cast'
 env['ASFLAGS'] = '--64'
+env['COCONUTFLAGS'] = '--target 3.8'
 
 # Add other languages here when you want to add language targets
 # Put 'name_of_language_directory' : 'file_extension'
+
 languages = {
+    'asm-x64': 's',
+    'bash': 'bash',
     'c': 'c',
+    'coconut': 'coco',
     'cpp': 'cpp',
-    'asm-x64': 's',
-    'rust': 'rs',
-    'go': 'go',
     'fortran': 'f90',
+    'go': 'go',
+    'java': 'java',
+    'javascript': 'js',
+    'julia': 'jl',
+    'kotlin': 'kt',
+    'lolcode': 'lol',
+    'lua': 'lua',
+    'php': 'php',
+    'powershell': 'ps1',
+    'python': 'py',
+    'ruby': 'rb',
+    'rust': 'rs',
+    'viml': 'vim',
 }
 
+# Do not add new Builders here, add them to the BUILDERS argument in the call to Environment above
 env.C = env.Program
 env.CPlusPlus = env.Program
 env.X64 = env.Program
 env.Fortran = env.Program
 
-Export('env')
+for language in available_languages:
+    Alias(language, f'#/build/{language}')
 
 sconscripts = []
-files_to_compile = {language: [] for language in languages}
-
-for chapter_dir in Path.cwd().joinpath('contents').iterdir():
-    if (code_dir := (chapter_dir / 'code')).exists():
-        for path in code_dir.iterdir():
-            if path.stem in languages:
-                # Check for overriding sconscript
-                if (sconscript_path := path / 'SConscript').exists():
-                    sconscripts.append(sconscript_path)
-                    SConscript(sconscript_path, exports='env')
+files_to_compile = {language: [] for language in languages if language in available_languages}
+
+FileInformation = namedtuple('FileInformation', ['path', 'chapter', 'language'])
+
+
+contents_path = Path.cwd().joinpath('contents')
+for chapter_dir in contents_path.iterdir():
+    for code_dir in chapter_dir.glob('**/code'):
+        # For nested chapters e.g. contents/convolutions/1d/
+        extended_chapter_path = code_dir.relative_to(contents_path).parent
+
+        for language_dir in code_dir.iterdir():
+            if (language := language_dir.stem) in available_languages:
+                new_files = [FileInformation(path=file_path,
+                                             chapter=extended_chapter_path,
+                                             language=language)
+                                             for file_path in language_dir.glob(f'**/*.{languages[language]}')
+                            ]
+                # Check for overriding SConscript
+                if (sconscript_path := language_dir / 'SConscript').exists():
+                    SConscript(sconscript_path, exports={'files_to_compile': new_files})
                 else:
-                    files_to_compile[path.stem].extend(path.glob(f'*.{languages[path.stem]}'))
+                    files_to_compile[language].extend(new_files)
 
-sconscript_dir_path = Path('sconscripts')
+sconscript_dir_path = Path.cwd().joinpath('sconscripts')
 for language, files in files_to_compile.items():
     if files:
         if (sconscript_path := sconscript_dir_path / f"{language}_SConscript").exists():
-            SConscript(sconscript_path, exports = {'files_to_compile': files,
-                                                   'language': language})
+            SConscript(sconscript_path, exports = {'files_to_compile': files})
         else:
             print(f'{language} file found at {files[0]}, but no sconscript file is present ')
 

SUMMARY.md

@@ -20,9 +20,13 @@
         * [Multiplication as a Convolution](contents/convolutions/multiplication/multiplication.md)
         * [Convolutions of Images (2D)](contents/convolutions/2d/2d.md)
         * [Convolutional Theorem](contents/convolutions/convolutional_theorem/convolutional_theorem.md)
+    * [Box Muller Transform](contents/box_muller/box_muller.md)
+        * [How costly is rejection sampling?](contents/box_muller/box_muller_rejection.md)
+    * [Probability Distributions](contents/probability_distributions/distributions.md)
 * [Tree Traversal](contents/tree_traversal/tree_traversal.md)
 * [Euclidean Algorithm](contents/euclidean_algorithm/euclidean_algorithm.md)
 * [Monte Carlo](contents/monte_carlo_integration/monte_carlo_integration.md)
+    * [Metropolis](contents/metropolis/metropolis.md)
 * [Matrix Methods](contents/matrix_methods/matrix_methods.md)
     * [Gaussian Elimination](contents/gaussian_elimination/gaussian_elimination.md)
     * [Thomas Algorithm](contents/thomas_algorithm/thomas_algorithm.md)
@@ -42,5 +46,6 @@
 * [Computer Graphics](contents/computer_graphics/computer_graphics.md)
     * [Flood Fill](contents/flood_fill/flood_fill.md)
 * [Quantum Information](contents/quantum_information/quantum_information.md)
+* [Cryptography](contents/cryptography/cryptography.md)
 * [Computus](contents/computus/computus.md)
 * [Approximate Counting Algorithm](contents/approximate_counting/approximate_counting.md)

builders/cargo.py

@@ -0,0 +1,41 @@
+from SCons.Builder import Builder
+from SCons.Script import Move
+import SCons.Util
+
+class ToolCargoWarning(SCons.Warnings.SConsWarning):
+    pass
+
+class CargoNotFound(ToolCargoWarning):
+    pass
+
+SCons.Warnings.enableWarningClass(ToolCargoWarning)
+
+def _detect(env):
+    try:
+        return env['cargo']
+    except KeyError:
+        pass
+
+    cargo = env.WhereIs('cargo')
+    if cargo:
+        return cargo
+
+    SCons.Warnings.warn(CargoNotFound, 'Could not detect cargo')
+
+def exists(env):
+    return env.Detect('cargo')
+
+
+def generate(env):
+    env['CARGO'] = _detect(env)
+    env['CARGOFLAGS'] = []
+    env['MANIFEST'] = []
+
+    rust_cargo_builder = Builder(
+            action=['"$CARGO" build $CARGOFLAGS --bins --manifest-path $MANIFEST',
+                    Move('$TARGET$PROGSUFFIX', 
+                         '$SOURCE_DIR/target/debug/main$PROGSUFFIX')
+                    ],
+            suffix='$PROGSUFFIX',
+            )
+    env.Append(BUILDERS={'cargo': rust_cargo_builder})

builders/coconut.py

@@ -0,0 +1,40 @@
+from SCons.Builder import Builder
+import SCons.Util
+
+class ToolCocoWarning(SCons.Warnings.SConsWarning):
+    pass
+
+class CoconutNotFound(ToolCocoWarning):
+    pass
+
+SCons.Warnings.enableWarningClass(ToolCocoWarning)
+
+def _detect(env):
+    try:
+        return env['coconut']
+    except KeyError:
+        pass
+
+    coconut = env.WhereIs('coconut')
+    if coconut:
+        return coconut
+
+    SCons.Warnings.warn(CoconutNotFound, 'Could not find Coconut executable')
+
+
+def generate(env):
+    env['COCONUT'] = _detect(env)
+    env['COCONUTFLAGS'] = []
+
+    coconut_compiler = Builder(
+        action='"$COCONUT" $COCONUTFLAGS $SOURCE $TARGET',
+        src_suffix='.coco',
+        suffix='.py',
+    )
+
+    env.Append(BUILDERS={'Coconut': coconut_compiler})
+
+def exists(env):
+    return env.Detect('coconut')
+
+

builders/go.py

@@ -0,0 +1,37 @@
+from SCons.Builder import Builder
+import SCons.Util
+
+class ToolGoWarning(SCons.Warnings.SConsWarning):
+    pass
+
+class GoNotFound(ToolGoWarning):
+    pass
+
+SCons.Warnings.enableWarningClass(ToolGoWarning)
+
+def _detect(env):
+    try:
+        return env['go']
+    except KeyError:
+        pass
+
+    go = env.WhereIs('go')
+    if go:
+        return go
+
+    SCons.Warnings.warn(GoNotFound, 'Could not find go executable')
+
+def exists(env):
+    env.Detect('go')
+
+def generate(env):
+    env['GO'] = _detect(env)
+    env['GOFLAGS'] = []
+
+    go_builder = Builder(
+        action='"$GO" build -o $TARGET $GOFLAGS $SOURCE',
+        src_suffix='.go',
+        suffix='$PROGSUFFIX',
+    )
+
+    env.Append(BUILDERS={'Go': go_builder})