Major rework to improve code quality and add automation checks (#805)

* delete secant method - it is identical to regula falsi

* document + improvize root finding algorithms

* attempt to document gaussian elimination

* added file brief

* commented doxygen-mainpage, added files-list link

* corrected files list link path

* files-list link correction - this time works :)

* document successive approximations

* cleaner equation

* updating DIRECTORY.md

* documented kmp string search

* document brute force string search

* document rabin-karp string search

* fixed mainpage readme

* doxygen v1.8.18 will suppress out the #minipage in the markdown

* cpplint correction for header guard style

* github action to auto format source code per cpplint standard

* updated setting to add 1 space before `private` and `public` keywords

* auto rename files and auto format code

* added missing "run" for step

* corrected asignmemt operation

* fixed trim and assign syntax

* added git move for renaming bad filenames

* added missing pipe for trim

* added missing space

* use old and new fnames

* store old fname using echo

* move files only if there is a change in filename

* put old filenames in quotes

* use double quote for old filename

* escape double quotes

* remove old_fname

* try escape characters and echo"

* add file-type to find

* cleanup echo

* ensure all trim variables are also in quotes

* try escape -quote again

* remove second escpe quote

* use single quote for first check

* use carets instead of quotes

* put variables in brackets

* remove -e from echo

* add debug echos

* try print0 flag

* find command with while instead of for-loop

* find command using IFS instead

* 🎉 IFS fix worked - escaped quotes for git mv

* protetc each word in git mv ..

* filename exists in lower cases - renamed

* 🎉 git push enabled

* updating DIRECTORY.md

* git pull & then push

* formatting filenames d7af6fdc8c

* formatting source-code for d7af6fdc8c

* remove allman break before braces

* updating DIRECTORY.md

* added missing comma lost in previous commit

* orchestrate all workflows

* fix yml indentation

* force push format changes, add title to DIRECTORY.md

* pull before proceeding

* reorganize pull commands

* use master branches for actions

* rename .cc files to .cpp

* added class destructor to clean up dynamic memory allocation

* rename to awesome workflow

* commented whole repo cpplint - added modified files lint check

* removed need for cpplint

* attempt to use actions/checkout@master

* temporary: no dependency on cpplint

* formatting filenames 153fb7b8a5

* formatting source-code for 153fb7b8a5

* updating DIRECTORY.md

* fix diff filename

* added comments to the code

* added test case

* formatting source-code for a850308fba

* updating DIRECTORY.md

* added machine learning folder

* added adaline algorithm

* updating DIRECTORY.md

* fixed issue [LWG2192](https://cplusplus.github.io/LWG/issue2192) for std::abs on MacOS

* add cmath for same bug: [LWG2192](https://cplusplus.github.io/LWG/issue2192) for std::abs on MacOS

* formatting source-code for f8925e4822

* use STL's inner_product

* formatting source-code for f94a330594

* added range comments

* define activation function

* use equal initial weights

* change test2 function to predict

* activation function not friend

* previous commit correction

* added option for predict function to return value before applying activation function as optional argument

* added test case to classify points lying within a sphere

* improve documentation for adaline

* formatting source-code for 15ec4c3aba

* added cmake to geometry folder

* added algorithm include for std::max

* add namespace - machine_learning

* add namespace - statistics

* add namespace - sorting

* added sorting algos to namespace sorting

* added namespace string_search

* formatting source-code for fd69530515

* added documentation to string_search namespace

* feat: Add BFS and DFS algorithms to check for cycle in a directed graph

* Remove const references for input of simple types

Reason: overhead on access

* fix bad code

sorry for force push

* Use pointer instead of the non-const reference

because apparently google says so.

* Remove a useless and possibly bad Graph constuctor overload

* Explicitely specify type of vector during graph instantiation

* updating DIRECTORY.md

* find openMP before adding subdirectories

* added kohonen self organizing map

* updating DIRECTORY.md

* remove older files and folders from gh-pages before adding new files

* remove chronos library due to inacceptability by cpplint

* use c++ specific static_cast instead

* initialize radom number generator

* updated image links with those from CPP repository

* rename computer.... folder to numerical methods

* added durand kerner method for root computation for arbitrarily large polynomials

* fixed additional comma

* fix cpplint errors

* updating DIRECTORY.md

* convert to function module

* update documentation

* move openmp to main loop

* added two test cases

* use INT16_MAX

* remove return statement from omp-for loop and use "break"

* run tests when no input is provided and skip tests when input polynomial is provided

* while loop cannot have break - replaced with continue and check is present in the main while condition

* (1) break while loop (2) skip runs on break_loop instead of hard-break

* add documentation images

* use long double for errors and tolerance checks

* make iterator variable i local to threads

* add critical secions to omp threads

* bugfix: move file writing outside of the parallel loop
othersie, there is no gurantee of the order of roots written to file

* rename folder to data_structures

* updating DIRECTORY.md

* fix ambiguous symbol `size`

* add data_structures to cmake

* docs: enable tree view, add timestamp in footer, try clang assistaed parsing

* doxygen - open links in external window

* remove invalid parameter from function docs

* use HTML5 img tag to resize images

* move file to proper folder

* fix documentations and cpplint

* formatting source-code for aacaf9828c

* updating DIRECTORY.md

* cpplint: add braces for multiple statement if

* add explicit link to badges

* remove  duplicate line

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* remove namespace indentation

* remove file associations in settings

* add author name

* enable cmake in subfolders of data_structures

* create and link object file

* cpp lint fixes and instantiate template classes

* cpp lint fixes and instantiate template classes

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* cpplint - ignore `build/include`

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* disable redundant gcc compilation in cpplint workflow

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* template header files contain function codes as well and removed redundant subfolders

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* updating DIRECTORY.md

* remove semicolons after functions in a class

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* cpplint header guard style

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* remove semilon

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* added LU decomposition algorithm

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* added QR decomposition algorithm

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* use QR decomposition to find eigen values

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* updating DIRECTORY.md

* use std::rand for thread safety

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* move srand to main()

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* cpplint braces correction

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* updated eigen value documentation

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* fix matrix shift doc

Signed-off-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>

* rename CONTRIBUTION.md to CONTRIBUTING.md #836

* remove 'sort alphabetical order' check

* added documentation check

* remove extra paranthesis

* added gitpod

* added gitpod link from README

* attempt to add vscode gitpod extensions

* update gitpod extensions

* add gitpod extensions cmake-tools and git-graph

* remove gitpod init and add commands

* use init to one time install doxygen, graphviz, cpplint

* use gitpod dockerfile

* add ninja build system to docker

* remove configure task

* add github prebuild specs to gitpod

* disable gitpod addcommit

* update documentation for kohonen_som

* added ode solve using forward euler method

* added mid-point euler ode solver

* fixed itegration step equation

* added semi-implicit euler ODE solver

* updating DIRECTORY.md

* fix cpplint issues - lines 117 and 124

* added documentation to ode group

* corrected semi-implicit euler function

* updated docs and test cases better structure

* replace `free` with `delete` operator

* formatting source-code for f55ab50cf2

* updating DIRECTORY.md

* main function must return

* added machine learning group

* added kohonen som topology algorithm

* fix graph image path

* updating DIRECTORY.md

* fix braces

* use snprintf instead of sprintf

* use static_cast

* hardcode character buffer size

* fix machine learning groups in documentation

* fix missing namespace function

* replace kvedala fork references to TheAlgorithms

* fix bug in counting_sort

Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com>
Co-authored-by: Anmol3299 <mittalanmol22@gmail.com>

strings/CMakeLists.txt

@@ -0,0 +1,18 @@
+# If necessary, use the RELATIVE flag, otherwise each source file may be listed
+# with full pathname. RELATIVE may makes it easier to extract an executable name
+# automatically.
+file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
+# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
+# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
+foreach( testsourcefile ${APP_SOURCES} )
+    # I used a simple string replace, to cut off .cpp.
+    string( REPLACE ".cpp" "" testname ${testsourcefile} )
+    add_executable( ${testname} ${testsourcefile} )
+
+    set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
+    if(OpenMP_CXX_FOUND)
+        target_link_libraries(${testname} OpenMP::OpenMP_CXX)
+    endif()
+    install(TARGETS ${testname} DESTINATION "bin/strings")
+
+endforeach( testsourcefile ${APP_SOURCES} )

strings/brute_force_string_searching.cpp

@@ -1,52 +1,57 @@
-#include  <iostream>
-#include  <string>
-#include  <vector>
-
-using std::string;
-
-int brute_force(string text, string pattern);
-std::vector<std::vector<string>> test_set  =   {
-    // {text, pattern, expected output}
-     {"a", "aa", "-1"},
-     {"a", "a", "0"},
-     {"ba", "b", "0"},
-     {"bba", "bb", "0"},
-     {"bbca", "c", "2"},
-     {"ab", "b", "1"}
-};
-
-int main() {
-    for  (size_t i  =  0 ;  i < test_set.size();  i++) {
-        int output  =  brute_force(test_set[i][0],  test_set[i][1]);
-        if (std::to_string(output)  ==  test_set[i][2])
-            std::cout  <<  "success\n";
-        else
-            std::cout  <<  "failure\n";
-    }
-    return 0;
-}
-
-/*
- *@description    Find a pattern in a string by comparing the pattern
- *                to every substring.
- *@param text     Any string that might contain the pattern.
- *@param pattern  String that we are searching for.
- *@return       Index where the pattern starts in the text or
- *                -1 if the pattern was not found.
+/**
+ * @file
+ * @brief          String pattern search - brute force
  */
+#include <iostream>
+#ifdef _MSC_VER
+#include <string>  // use this for MS Visucal C++
+#else
+#include <cstring>
+#endif
+#include <vector>
 
-int brute_force(string text, string pattern) {
-    size_t pat_l  =  pattern.length();
-    size_t txt_l  =  text.length();
-    int index  =  -1;
-    if (pat_l  <=  txt_l) {
-        for  (size_t i = 0;  i < txt_l-pat_l+1; i++) {
-            string s  =  text.substr(i, pat_l);
-            if (s  ==  pattern) {
-                index  =  i;
+namespace string_search {
+/**
+ * Find a pattern in a string by comparing the pattern to every substring.
+ * @param text     Any string that might contain the pattern.
+ * @param pattern  String that we are searching for.
+ * @return         Index where the pattern starts in the text
+ * @return         -1 if the pattern was not found.
+ */
+int brute_force(const std::string &text, const std::string &pattern) {
+    size_t pat_l = pattern.length();
+    size_t txt_l = text.length();
+    int index = -1;
+    if (pat_l <= txt_l) {
+        for (size_t i = 0; i < txt_l - pat_l + 1; i++) {
+            std::string s = text.substr(i, pat_l);
+            if (s == pattern) {
+                index = i;
                 break;
             }
         }
     }
     return index;
 }
+}  // namespace string_search
+
+using string_search::brute_force;
+
+/** set of test cases */
+const std::vector<std::vector<std::string>> test_set = {
+    // {text, pattern, expected output}
+    {"a", "aa", "-1"},  {"a", "a", "0"},    {"ba", "b", "0"},
+    {"bba", "bb", "0"}, {"bbca", "c", "2"}, {"ab", "b", "1"}};
+
+/** Main function */
+int main() {
+    for (size_t i = 0; i < test_set.size(); i++) {
+        int output = brute_force(test_set[i][0], test_set[i][1]);
+
+        if (std::to_string(output) == test_set[i][2])
+            std::cout << "success\n";
+        else
+            std::cout << "failure\n";
+    }
+    return 0;
+}

strings/knuth_morris_pratt.cpp

@@ -1,64 +1,95 @@
-/*
-    The Knuth-Morris-Pratt Algorithm for finding a pattern within a piece of text
-    with complexity O(n + m)
-    1) Preprocess pattern to identify any suffixes that are identical to prefixes
-        This tells us where to continue from if we get a mismatch between a character in our pattern
-        and the text.
-    2) Step through the text one character at a time and compare it to a character in the pattern
-        updating our location within the pattern if necessary
-*/
+/**
+ * \file
+ * \brief The [Knuth-Morris-Pratt
+ * Algorithm](https://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm) for
+ * finding a pattern within a piece of text with complexity O(n + m)
+ *
+ * 1. Preprocess pattern to identify any suffixes that are identical to
+ * prefixes. This tells us where to continue from if we get a mismatch between a
+ * character in our pattern and the text.
+ * 2. Step through the text one character at a time and compare it to a
+ * character in the pattern updating our location within the pattern if
+ * necessary
+ */
 
-#include<iostream>
-#include<vector>
-#include<string>
-using namespace std;
-vector<int> getFailureArray(string pattern){
-    int pattern_length=pattern.size();
-    vector<int>failure(pattern_length+1);
-    failure[0]=-1;
-    int j=-1;
-    for(int i=0; i<pattern_length; i++){
-        while(j!=-1&&pattern[j]!=pattern[i]){
-            j=failure[j];
+#include <iostream>
+#ifdef _MSC_VER
+#include <string>  // use this for MS Visucal C++
+#else
+#include <cstring>
+#endif
+#include <vector>
+
+/** \namespace string_search
+ * \brief String search algorithms
+ */
+namespace string_search {
+/**
+ * Generate the partial match table aka failure function for a pattern to
+ * search.
+ * \param[in] pattern text for which to create the partial match table
+ * \returns the partial match table as a vector array
+ */
+std::vector<int> getFailureArray(const std::string &pattern) {
+    int pattern_length = pattern.size();
+    std::vector<int> failure(pattern_length + 1);
+    failure[0] = -1;
+    int j = -1;
+
+    for (int i = 0; i < pattern_length; i++) {
+        while (j != -1 && pattern[j] != pattern[i]) {
+            j = failure[j];
         }
         j++;
-        failure[i+1]=j;
+        failure[i + 1] = j;
     }
     return failure;
 }
-bool kmp(string pattern,string text){
-    int text_length=text.size(),pattern_length=pattern.size();
-    vector<int>failure=getFailureArray(pattern);
-    int k=0;
-    for(int  j=0; j<text_length; j++){
-        while(k!=-1&&pattern[k]!=text[j]){
-            k=failure[k];
+
+/**
+ * KMP algorithm to find a pattern in a text
+ * \param[in] pattern string pattern to search
+ * \param[in] text text in which to search
+ * \returns `true` if pattern was found
+ * \returns `false` if pattern was not found
+ */
+bool kmp(const std::string &pattern, const std::string &text) {
+    int text_length = text.size(), pattern_length = pattern.size();
+    std::vector<int> failure = getFailureArray(pattern);
+
+    int k = 0;
+    for (int j = 0; j < text_length; j++) {
+        while (k != -1 && pattern[k] != text[j]) {
+            k = failure[k];
         }
         k++;
-        if(k==pattern_length)return true;
+        if (k == pattern_length)
+            return true;
     }
     return false;
 }
+}  // namespace string_search
 
-int main()
-{   
-   
-    string text="alskfjaldsabc1abc1abc12k23adsfabcabc";
-    string pattern="abc1abc12l";
-    if(kmp(pattern,text)==true){
-        cout<<"Found"<<endl;
+using string_search::kmp;
+
+/** Main function */
+int main() {
+    std::string text = "alskfjaldsabc1abc1abc12k23adsfabcabc";
+    std::string pattern = "abc1abc12l";
+
+    if (kmp(pattern, text) == true) {
+        std::cout << "Found" << std::endl;
+    } else {
+        std::cout << "Not Found" << std::endl;
     }
-    else{
-        cout<<"Not Found"<<endl;
-    }
-    text="abcabc";
-    pattern="bca";
-    if(kmp(pattern,text)==true){
-        cout<<"Found"<<endl;
-    }
-    else{
-        cout<<"Not Found"<<endl;
+
+    text = "abcabc";
+    pattern = "bca";
+    if (kmp(pattern, text) == true) {
+        std::cout << "Found" << std::endl;
+    } else {
+        std::cout << "Not Found" << std::endl;
     }
+
     return 0;
 }
-

strings/rabin_karp.cpp

@@ -1,39 +1,65 @@
-/*
- * file name : rabin_karp.cpp
- * author    : Amit Kumar 
- * Copyright : 2020 , Amit Kumar 
- * version   : 1.0
+/**
+ * \file
+ * \brief The [Rabin-Karp
+ * Algorithm](https://en.wikipedia.org/wiki/Rabin–Karp_algorithm) for finding a
+ * pattern within a piece of text with complexity O(n + m)
  */
-#include<cassert>
-#include<cmath>
-#include<iostream>
-#include<string>
+#include <cassert>
+#include <cmath>
+#include <iostream>
+#ifdef _MSC_VER
+#include <string>  // use this for MS Visucal C++
+#else
+#include <cstring>
+#endif
 
-using std::string;
-using std::pow;
+#define PRIME 5  ///< Prime modulus for hash functions
 
-#define PRIME 5
-
-int64_t create_hash(string s , int n) {
+namespace string_search {
+/**
+ * convert a string to an intger - called as hashing function
+ * \param[in] s source of string to hash
+ * \param[in] n length of substring to hash
+ * \returns hash integer
+ */
+int64_t create_hash(const std::string& s, int n) {
     int64_t result = 0;
-    for ( int i = 0; i < n; ++i ) {
-        result += (int64_t)(s[i] * (int64_t)pow(PRIME , i));
+    for (int i = 0; i < n; ++i) {
+        result += (int64_t)(s[i] * (int64_t)pow(PRIME, i));
     }
     return result;
 }
 
-int64_t recalculate_hash(string s , int old_index ,
-        int new_index , int64_t old_hash , int patLength) {
+/**
+ * re-hash a string using known existing hash
+ * \param[in] s source of string to hash
+ * \param[in] old_index previous index of string
+ * \param[in] new_index new index of string
+ * \param[in] old_hash previous hash of substring
+ * \param[in] patLength length of substring to hash
+ * \returns new hash integer
+ */
+int64_t recalculate_hash(const std::string& s, int old_index, int new_index,
+                         int64_t old_hash, int patLength) {
     int64_t new_hash = old_hash - s[old_index];
     new_hash /= PRIME;
-    new_hash += (int64_t)(s[new_index]*(int64_t)pow(PRIME, patLength-1));
+    new_hash += (int64_t)(s[new_index] * (int64_t)pow(PRIME, patLength - 1));
     return new_hash;
 }
 
-bool check_if_equal(string str1 , string str2 ,
-                    int start1 , int end1 ,
-                    int start2 , int end2) {
-    if (end1-start1 != end2-start2) {
+/**
+ * compare if two sub-strings are equal
+ * \param[in] str1 string pattern to search
+ * \param[in] str2 text in which to search
+ * \param[in] start1,end1 start and end indices for substring in str1
+ * \param[in] start2,end2 start and end indices for substring in str2
+ * \returns `true` if pattern was found
+ * \returns `false` if pattern was not found
+ * @note can this be replaced by std::string::compare?
+ */
+bool check_if_equal(const std::string& str1, const std::string& str2,
+                    int start1, int end1, int start2, int end2) {
+    if (end1 - start1 != end2 - start2) {
         return false;
     }
     while (start1 <= end1 && start2 <= end2) {
@@ -46,33 +72,40 @@ bool check_if_equal(string str1 , string str2 ,
     return true;
 }
 
-/*
- *  @description : search pattern in the given text 
- *  @param : string str
- *  @param : string pat
- *  @return index of first occurrence of pattern or -1 if pattern not found
+/**
+ *  Perform string pattern search using Rabin-Karp algorithm
+ *  @param[in] str string to search in
+ *  @param[in] pat pattern to search for
+ *  @return index of first occurrence of pattern
+ *  @return -1 if pattern not found
  */
 
-int rabin_karp(const string &str , const string& pat) {
-    int64_t pat_hash = create_hash(pat , pat.size());
-    int64_t str_hash = create_hash(str , pat.size());
-    for (int i=0;  i <= str.size()-pat.size(); ++i) {
+int rabin_karp(const std::string& str, const std::string& pat) {
+    int64_t pat_hash = create_hash(pat, pat.size());
+    int64_t str_hash = create_hash(str, pat.size());
+    for (int i = 0; i <= str.size() - pat.size(); ++i) {
         if (pat_hash == str_hash &&
-            check_if_equal(str , pat , i , i+pat.size()-1 , 0 , pat.size()-1)) {
-                return i;
+            check_if_equal(str, pat, i, i + pat.size() - 1, 0,
+                           pat.size() - 1)) {
+            return i;
         }
-        if (i < str.size()-pat.size()) {
+        if (i < str.size() - pat.size()) {
             str_hash =
-                recalculate_hash(str, i, i+pat.size(), str_hash, pat.size());
+                recalculate_hash(str, i, i + pat.size(), str_hash, pat.size());
         }
     }
     return -1;  // return -1 if given pattern not found
 }
 
+}  // namespace string_search
+
+using string_search::rabin_karp;
+
+/** Main function */
 int main(void) {
-    assert(rabin_karp("helloWorld", "world")    == -1);
-    assert(rabin_karp("helloWorld", "World")    ==  5);
-    assert(rabin_karp("this_is_c++" , "c++")   ==  8);
-    assert(rabin_karp("happy_coding", "happy") ==  0);
+    assert(rabin_karp("helloWorld", "world") == -1);
+    assert(rabin_karp("helloWorld", "World") == 5);
+    assert(rabin_karp("this_is_c++", "c++") == 8);
+    assert(rabin_karp("happy_coding", "happy") == 0);
     return 0;
 }