Add cpp randomizer

Author: 64json

builders/cpp.js

@@ -55,7 +55,7 @@ project(tracers)
 
 set(CMAKE_CXX_STANDARD 11)
 
-add_library(tracers Tracer.cpp Tracer.h ${tracers.map(tracer => `${tracer.name}.cpp ${tracer.name}.h`).join(' ')})
+add_library(tracers Randomize.h Tracer.cpp Tracer.h ${tracers.map(tracer => `${tracer.name}.cpp ${tracer.name}.h`).join(' ')})
 
 set_target_properties(tracers
     PROPERTIES

languages/cpp/CMakeLists.txt

@@ -3,3 +3,5 @@ cmake_minimum_required(VERSION 3.2)
 include_directories(include)
 
 add_subdirectory(src)
+
+add_subdirectory(test)

languages/cpp/src/.gitignore

@@ -1,4 +1,5 @@
 /CMakeLists.txt
 /*.cpp
 /*.h
-!/Tracer.*
+!/Tracer.*
+!/Randomize.*

languages/cpp/src/Randomize.h

@@ -0,0 +1,206 @@
+#ifndef PROJECT_RANDOMIZE_H
+#define PROJECT_RANDOMIZE_H
+
+#include <random>
+#include <algorithm>
+
+namespace Randomize {
+    using std::string;
+    using std::mt19937;
+
+    template<class T>
+    class Randomizer {
+    public:
+        Randomizer() {
+        }
+
+        virtual T create() {
+        }
+    };
+
+
+    class Integer : public Randomizer<int> {
+    private:
+        int _min;
+        int _max;
+
+        mt19937 rng;
+
+    public:
+        Integer(int min = 1, int max = 9) {
+            _min = min;
+            _max = max;
+
+            rng.seed(std::random_device()());
+        }
+
+        int create() {
+            std::uniform_int_distribution<int> dist6(_min, _max);
+            return dist6(rng);
+        }
+    };
+
+
+    class Double : public Randomizer<double> {
+    private:
+        double _min;
+        double _max;
+
+        mt19937 rng;
+
+    public:
+        Double(double min = 0, double max = 1) {
+            _min = min;
+            _max = max;
+
+            rng.seed(std::random_device()());
+        }
+
+        double create() {
+            std::uniform_real_distribution<double> dist6(_min, _max);
+            return dist6(rng);
+        }
+    };
+
+
+    class String : public Randomizer<string> {
+    private:
+        int _length;
+        string _letters;
+
+    public:
+        String(int length = 16, string letters = "abcdefghijklmnopqrstuvwxyz") {
+            _length = length;
+            _letters = letters;
+        }
+
+        string create() {
+            string text = "";
+            Integer randomizer(0, _letters.length() - 1);
+            for (int i = 0; i < _length; i++) {
+                text += _letters[randomizer.create()];
+            }
+            return text;
+        }
+    };
+
+
+    template<class T>
+    class Array2D : public Randomizer<T **> {
+    private:
+        int _N;
+        int _M;
+        Randomizer<T> *_randomizer;
+        bool _sorted;
+
+    public:
+        Array2D(int N = 10, int M = 10, Randomizer<T> &randomizer = *(new Integer())) {
+            _N = N;
+            _M = M;
+            _randomizer = &randomizer;
+            _sorted = false;
+        }
+
+        Array2D sorted(bool sorted = true) {
+            _sorted = sorted;
+            return *this;
+        }
+
+        T **create() {
+            T **D = new T *[_N];
+            for (int i = 0; i < _N; i++) {
+                D[i] = new T[_M];
+                for (int j = 0; j < _M; j++) {
+                    D[i][j] = (*_randomizer).create();
+                }
+                if (_sorted) std::sort(D[i], D[i] + _M);
+            }
+            return D;
+        }
+    };
+
+
+    template<class T>
+    class Array1D : public Randomizer<T *> {
+    private:
+        int _N;
+        Randomizer<T> *_randomizer;
+        bool _sorted;
+
+    public:
+        Array1D(int N = 10, Randomizer<T> &randomizer = *(new Integer())) {
+            _N = N;
+            _randomizer = &randomizer;
+            _sorted = false;
+        }
+
+        Array1D sorted(bool sorted = true) {
+            _sorted = sorted;
+            return *this;
+        }
+
+        T *create() {
+            T *D = new T[_N];
+            for (int i = 0; i < _N; i++) {
+                D[i] = (*_randomizer).create();
+            }
+            if (_sorted) std::sort(D, D + _N);
+            return D;
+        }
+    };
+
+
+    template<class T>
+    class Graph : public Randomizer<T **> {
+    private:
+        int _N;
+        double _ratio;
+        Randomizer<T> *_randomizer;
+        bool _directed;
+        bool _weighted;
+
+    public:
+        Graph(int N = 5, double ratio = .3, Randomizer<T> &randomizer = *(new Integer())) {
+            _N = N;
+            _ratio = ratio;
+            _randomizer = &randomizer;
+            _directed = true;
+            _weighted = false;
+        }
+
+        Graph directed(bool directed = true) {
+            _directed = directed;
+            return *this;
+        }
+
+        Graph weighted(bool weighted = true) {
+            _weighted = weighted;
+            return *this;
+        }
+
+        T **create() {
+            T **G = new T *[_N];
+            for (int i = 0; i < _N; i++) {
+                G[i] = new T[_N];
+            }
+            Double ratioRandomizer;
+            for (int i = 0; i < _N; i++) {
+                G[i][i] = 0;
+                T value = ratioRandomizer.create() < _ratio ? _weighted ? (*_randomizer).create() : 1 : 0;
+                if (_directed) {
+                    for (int j = 0; j < _N; j++) {
+                        if (i == j) continue;
+                        G[i][j] = value;
+                    }
+                } else {
+                    for (int j = 0; j < i; j++) {
+                        G[i][j] = G[j][i] = value;
+                    }
+                }
+            }
+            return G;
+        }
+    };
+}
+
+#endif //PROJECT_RANDOMIZE_H

languages/cpp/src/Tracer.cpp

@@ -35,5 +35,9 @@ void Tracer::onExit() {
     cout << traces.dump(2);
 }
 
-int registered = atexit(Tracer::onExit);
-//TODO: add randomizer
+int init() {
+    atexit(Tracer::onExit);
+    return 0;
+}
+
+int _ = init();

languages/cpp/src/Tracer.h

@@ -2,12 +2,13 @@
 #define CPP_TRACER_H
 
 #include <string>
-#include "../include/json.hpp"
-
-using namespace std;
-using json = nlohmann::json;
+#include "json.hpp"
 
 class Tracer {
+protected:
+    using string = std::string;
+    using json = nlohmann::json;
+
 private:
     static int tracerCount;
     static json traces;

languages/cpp/test/CMakeLists.txt

@@ -0,0 +1,10 @@
+cmake_minimum_required(VERSION 3.2)
+project(tracers_test)
+
+set(CMAKE_CXX_STANDARD 11)
+
+include_directories(../src)
+
+add_executable(tracers_test main.cpp)
+
+target_link_libraries(tracers_test tracers)

languages/cpp/test/main.cpp

@@ -0,0 +1,20 @@
+#include <string>
+#include <iostream>
+#include "LogTracer.h"
+#include "Randomize.h"
+
+using namespace std;
+using namespace Randomize;
+
+int main() {
+    int N = 5;
+    int **graph = Graph<int>(N, 1, *(new Integer(1, 5))).weighted(true).create();
+    for (int i = 0; i < N; i++) {
+        for (int j = 0; j < N; j++) {
+            cout << graph[i][j] << " ";
+        }
+        cout << endl;
+    }
+//    int **arr = randomizer->create();
+    return 0;
+}