Add vector logic Thomas

Author: Meeeds

.gitignore

@@ -0,0 +1,3 @@
+
+*.exe
+*.txt

.vscode/settings.json

@@ -0,0 +1,63 @@
+{
+    "C_Cpp.default.cppStandard": "c++20",
+    "files.associations": {
+        "limits": "cpp",
+        "algorithm": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "cctype": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "exception": "cpp",
+        "initializer_list": "cpp",
+        "ios": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "new": "cpp",
+        "ostream": "cpp",
+        "random": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "string": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "typeinfo": "cpp",
+        "utility": "cpp",
+        "vector": "cpp",
+        "xfacet": "cpp",
+        "xiosbase": "cpp",
+        "xlocale": "cpp",
+        "xlocinfo": "cpp",
+        "xlocnum": "cpp",
+        "xmemory": "cpp",
+        "xstddef": "cpp",
+        "xstring": "cpp",
+        "xtr1common": "cpp",
+        "xutility": "cpp",
+        "iomanip": "cpp",
+        "charconv": "cpp",
+        "format": "cpp",
+        "locale": "cpp",
+        "mutex": "cpp",
+        "ratio": "cpp",
+        "stop_token": "cpp",
+        "thread": "cpp",
+        "xlocbuf": "cpp",
+        "xlocmes": "cpp",
+        "xlocmon": "cpp",
+        "xloctime": "cpp"
+    }
+}

.vscode/tasks.json

@@ -0,0 +1,52 @@
+{
+    "tasks": [
+        {
+            "type": "cppbuild",
+            "label": "C/C++: g++.exe build active file",
+            "command": "C:\\msys64\\mingw64\\bin\\g++.exe",
+            "args": [
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "Task generated by Debugger."
+        },
+        {
+            "type": "cppbuild",
+            "label": "C/C++: release g++.exe",
+            "command": "C:\\msys64\\mingw64\\bin\\g++.exe",
+            "args": [
+                "-O2",
+                "-fdiagnostics-color=always",
+                "-g",
+                "${file}",
+                "-o",
+                "${fileDirname}\\${fileBasenameNoExtension}_R3.exe"
+            ],
+            "options": {
+                "cwd": "${fileDirname}"
+            },
+            "problemMatcher": [
+                "$gcc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            },
+            "detail": "My task release"
+        }
+    ],
+    "version": "2.0.0"
+}

random_walk.cpp

@@ -3,6 +3,8 @@
 #include <string>
 #include <random>
 #include <limits>
+#include <algorithm>
+
 
 using namespace std;
 
@@ -31,12 +33,14 @@ bool no_need_to_to_continue(vector<int> current_point, int index, int maxIndex)
 int main()
 {
     //int MAX_TRY_BEFORE_GIVEUP = std::numeric_limits<int>::max();
-    int MAX_TRY_BEFORE_GIVEUP = 1000000;
+    int MAX_TRY_BEFORE_GIVEUP = std::numeric_limits<int>::max();;
     int DIMENSION = 3;
-    int NUMBER_OF_TRY = 10000;
-    cout << "aMAX_TRY_BEFORE_GIVEUP=" << MAX_TRY_BEFORE_GIVEUP << endl;
+    int NUMBER_OF_TRY = 1000;
+    int MODULO = 3;
+    cout << "MAX_TRY_BEFORE_GIVEUP=" << MAX_TRY_BEFORE_GIVEUP << endl;
     cout << "DIMENSION=" << DIMENSION << endl;
     cout << "NUMBER_OF_TRY=" << NUMBER_OF_TRY << endl;
+    cout << "MODULO=" << MODULO << endl;
 
     std::random_device rd; // obtain a random number from hardware
     std::mt19937 gen(rd()); // seed the generator
@@ -56,6 +60,8 @@ int main()
     //counters
     int went_back_to_start_count = 0;
     int failure_count = 0;
+    int max_steps_before_going_back = 0;
+    vector<int> steps_it_failed;
     for(int i=0;  i < NUMBER_OF_TRY; ++i){
 
         int percent = (100 * i) / NUMBER_OF_TRY;
@@ -80,21 +86,25 @@ int main()
             int walk_percent = 100*( (float) j / MAX_TRY_BEFORE_GIVEUP);
             if (walk_percent >= walk_nextPrint)
             {
-                //std::cout << "\rWalk: " << std::string(walk_percent/5, '|') << walk_percent << "%";
+                std::cout << "\rWalk: " << std::string(walk_percent/5, '|') << walk_percent << "%";
                 std::cout.flush();
                 walk_nextPrint += walk_step;
             }
 
             //go +1 or -1 ?
-            int step = 0;
+            int aStep = 0;
             if (std::rand() % 2 == 0){
-                step = 1;
+                aStep = 1;
             }else{
-                step = -1;
+                aStep = -1;
             }
 
             //go +1 or -1 on a rdm direction
-            current_point[distr_index(gen)]+=step;
+            int random_index = distr_index(gen);
+            current_point[random_index] += aStep;
+            if ( MODULO > 0 && random_index == (DIMENSION-1)) {
+                current_point[random_index] = (current_point[random_index] + MODULO ) % MODULO;
+            }
 
             //did we went back to zero ?
             bool went_back_to_start = true;
@@ -108,6 +118,10 @@ int main()
             if (went_back_to_start) {
                 cout << " went_back_to_start loop " << i << " after " << j+1 << " steps " << endl;
                 went_back_to_start_count++;
+                steps_it_failed.push_back(j+1);
+                if (j+1 > max_steps_before_going_back){
+                    max_steps_before_going_back = j+1;
+                }
                 break;
             }else if (j==MAX_TRY_BEFORE_GIVEUP-1){
                 failure_count++;
@@ -121,6 +135,13 @@ int main()
         }
     }
 
+    std::sort (steps_it_failed.begin(), steps_it_failed.end());
     std::cout << "went_back_to_start_count " << went_back_to_start_count << endl;
     std::cout << "failure_count " << failure_count << endl;
+    std::cout << "max_steps_before_going_back " << max_steps_before_going_back << endl;
+    cout << "steps_it_failed = [ ";
+    for (auto const &here: steps_it_failed) {
+        cout << here << ", ";
+    }
+    cout << " ]" << endl;
 }

random_walk_vector.cpp

@@ -0,0 +1,138 @@
+#include <iostream>
+#include <vector>
+#include <string>
+#include <random>
+#include <limits>
+#include <algorithm>
+#include <iomanip>
+
+using namespace std;
+
+
+
+bool no_need_to_to_continue(vector<int> current_point, int index, int maxIndex) {
+    int total = 0;
+    for(int val : current_point){
+        total+=std::abs(val);
+    }
+    if (total > (maxIndex-index) ){
+        cout << " no_need_to_to_continue(" << maxIndex-index << ")" << " total=" << total << endl;
+        return true;
+    }
+    return false;
+}
+
+class Points {
+    public : 
+
+    Points() = default;
+
+    Points(int aDimension)
+    {
+        for(int i=0;  i < aDimension; ++i){
+            _current_point.push_back(0);
+        }  
+    }
+
+    bool is_zero(){
+        for(int k=0;  k < _current_point.size(); ++k){
+            if(_current_point[k]!=0){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    void print_point() {
+        cout << "_current_point=" ; 
+        for(int l=0;  l < _current_point.size(); ++l){
+            cout << _current_point[l] << ", " ;
+        }
+        cout << endl;
+    }
+
+    vector<int> _current_point;
+};
+
+int main()
+{
+    unsigned int MAX_TRY_BEFORE_GIVEUP = std::numeric_limits<unsigned int>::max();
+    //int MAX_TRY_BEFORE_GIVEUP = 10000;
+    int DIMENSION = 3;
+    int NUMBER_OF_TRY = 1000;
+    int MODULO = 3;
+    cout << "MAX_TRY_BEFORE_GIVEUP=" << MAX_TRY_BEFORE_GIVEUP << endl;
+    cout << "DIMENSION=" << DIMENSION << endl;
+    cout << "NUMBER_OF_TRY=" << NUMBER_OF_TRY << endl;
+    cout << "MODULO=" << MODULO << endl;
+
+    std::random_device rd; // obtain a random number from hardware
+    std::mt19937 gen(rd()); // seed the generator
+    std::uniform_int_distribution<> distr_index(0, DIMENSION-1); // define the range
+
+
+    //fill the vector with the dimension size number of try
+
+    vector<Points> global_vector;
+    for(int i=0;  i < NUMBER_OF_TRY; ++i){
+        global_vector.push_back(Points(DIMENSION));
+    }
+
+    //to print overall progress
+    double step = 0.1;
+    double nextPrint = step;
+
+    //counters
+    int went_back_to_start_count = 0;
+    int failure_count = 0;
+    int max_steps_before_going_back = 0;
+    for(unsigned int i=0;  i < MAX_TRY_BEFORE_GIVEUP; ++i){
+        
+        double percent = 100*( (double) i / MAX_TRY_BEFORE_GIVEUP);
+        if (percent >= nextPrint)
+        {
+            float failures = (100.0 * global_vector.size() ) / NUMBER_OF_TRY;
+            std::cout << "FAILURES " << std::fixed << setprecision(2) << failures << "%" 
+                << " Global progress:  " << setfill(' ') << setw(2) << percent << "%" << " steps done: " << i << endl;
+            std::cout.flush();
+            if(nextPrint>2){
+                nextPrint += 10*step;
+            }else{
+                nextPrint += step;
+            }
+        }
+        //go one step for each point in the global vector
+        for (auto it = global_vector.begin(); it != global_vector.end(); ){
+            
+            //go +1 or -1 ?
+            int aStep = 0;
+            if (std::rand() % 2 == 0){
+                aStep = 1;
+            }else{
+                aStep = -1;
+            }
+
+            //go +1 or -1 on a rdm direction
+            int random_index = distr_index(gen);
+            it->_current_point[random_index] += aStep;
+            if ( MODULO > 0 && random_index == (DIMENSION-1)) {
+                it->_current_point[random_index] = (it->_current_point[random_index] + MODULO ) % MODULO;
+            }
+
+            if(it->is_zero()){
+                std::cout << "i = " << i << " going to erase ";
+                it->print_point();
+                global_vector.erase(it);
+                went_back_to_start_count++;
+            }else{
+                ++it;
+            }
+        }
+    }
+
+    failure_count=global_vector.size();
+    std::cout << "went_back_to_start_count " << went_back_to_start_count << endl;
+    std::cout << "failure_count " << failure_count << endl;
+    std::cout << "max_steps_before_going_back " << max_steps_before_going_back << endl;
+    
+}