initial

Author: dmitryikh

.gitignore

@@ -0,0 +1 @@
+*.swp

README.md

@@ -0,0 +1,94 @@
+# C++11 vs Rust comparison
+
+## Intro
+
+The goal of this project is to understand programming idioms of Rust, and
+roughly measure Rust performance compared to C++11. For this purpose several
+well known algorithmic problems were considered. The problems were inspired and
+evolved from great computer science course "Algorithms: Theory & Practice" on
+Stepik paltform. Here the link to the course:
+https://stepik.org/course/217/syllabus . 
+
+## Problems
+
+Here is short overview of the programming problems considered in the project.
+More detailed description of each task could be found in the tasks' folders.
+
+`huffman_encoding` and `huffman_decoding` are about of building optimal prefix
+code for the given message and decoding it back. These problems are about to
+work with priority queque (heap data structure), binary tree and hash map.
+Particular realisations on Rust and C++11 relies on standard libraries'
+realisation of hash map and priority queue implementing only binary tree to
+solve the problem. Complexity is O(N) for building the code.
+
+`binary_search` is quite well known and straightforward algorithm for searching
+of the particular value in a sorted array. Here is no significant distinctions
+in realisations. Complexity is O(logN).
+
+`mergesort` algorithm of sorting is implemented in non-recursion way in order
+to avoid stack overflow. Complexity is O(N logN).
+
+`levenshtein` distance is usually used to quantify the difference between two
+strings. The algorithm is implemented in dynamic prgramming manner. Complexity is O(N^2).
+
+## Folders overview
+
+Each problem can be found in the folder with the same name. In each folder here
+are `main.cpp` and `main.rs` source codes which is solving the described
+problems in C++11 and Rust. Also here is `Makefile` in each folder to compile
+the programs, prepare test data and perform performance measures. The common
+part of the `Makefile` can be found in `common/common.make`.
+
+Also each problem's folder contains `generator` project on Rust which is
+dedicated to generate input data for prgrams for testing purposes.
+
+Although one can find brief overview of the problems above, in the particular
+folder here is `README.md` with more formal problem descriptions and notes.
+
+## Performance testing set up
+
+Each problem has Make scenario with 4 rules: `main_rust`, `main_cpp`, `gen` and
+`bench`. First two are about compiling the programs. Every program recieves its
+input on `stdin` and write results in `stdout`. `gen` will prepare test data:
+three input sets `inp_low`, `inp_mid`, `inp_hi` with increasing problem sizes.
+Generally, `inp_low` contains smallest inputs, and `inp_hi` contains millions
+of entities and it usually takes few seconds to solve the problem of a such size.
+`bench` rule will call `common/compare_performace.sh` which will perform N (N =
+10) runs of every input on evety program and everage the result. Occasianally,
+here is not standard command line tool for measure the program runtime in
+milisecond resolution for Mac Os X and Linux.. Therefore in `common/measure`
+you will find a small rust program to meausre the runtime of another program.
+To run all steps in once, one can use `run_bench.sh`. It will take up to ten
+minutes to perform all compilations, generations and performance measures. 
+
+## Compilation
+
+The next command line is used to compile C++ program:
+
+```
+	g++ -std=c++11 -O2 -o main_cpp main.cpp
+```
+
+The next command line is used to compile Rust program:
+
+```
+	rustc -O --crate-name main_rust main.rs
+```
+
+
+## Requirements
+
+One needs to run Mac Os X or Linux with installed to PATH GNU C++ compiler or Clang and Rust. By the author the presented project was tested with the next softwares:
+
+```
+> rustc -V
+Rustc 1.20.0 (f3d6973f4 2017-08-27)
+
+> g++ -v
+...
+gcc version 7.2.0
+```
+
+## License
+
+Actually here is no any type of restrictions on the materials in this repository. Anyone can do anything with the source code and results. 

benchmark_results_raw.md

@@ -0,0 +1,88 @@
+The test was launched by `run_bench.sh` script. The testing hardware is: Intel Core i7-4770, 16GB DDR3, SSD, Linux Mint 18.1 64-bit.
+The output:
+```
+Test 4_2_5
+
+Compiling programs..
+Generate test data..
+Measuring performance..
+../common/compare_performance.sh
+Averaging performance of 10 runs..
+./main_cpp:
+  test inp_low: .00168 sec
+  test inp_mid: .02829 sec
+  test inp_hi: .27003 sec
+
+./main_rust:
+  test inp_low: .00169 sec
+  test inp_mid: .04197 sec
+  test inp_hi: .43336 sec
+
+Test 4_2_6
+
+Compiling programs..
+Generate test data..
+Measuring performance..
+../common/compare_performance.sh
+Averaging performance of 10 runs..
+./main_cpp:
+  test inp_low: .00185 sec
+  test inp_mid: .04698 sec
+  test inp_hi: .43825 sec
+
+./main_rust:
+  test inp_low: .00152 sec
+  test inp_mid: .02622 sec
+  test inp_hi: .24990 sec
+
+Test 6_1_4
+
+Compiling programs..
+Generate test data..
+Measuring performance..
+../common/compare_performance.sh
+Averaging performance of 10 runs..
+./main_cpp:
+  test inp_low: .00288 sec
+  test inp_mid: .15820 sec
+  test inp_hi: 1.85318 sec
+
+./main_rust:
+  test inp_low: .00223 sec
+  test inp_mid: .12787 sec
+  test inp_hi: 1.55638 sec
+
+Test 6_4_5
+
+Compiling programs..
+Generate test data..
+Measuring performance..
+../common/compare_performance.sh
+Averaging performance of 10 runs..
+./main_cpp:
+  test inp_low: .00312 sec
+  test inp_mid: .19478 sec
+  test inp_hi: 2.10201 sec
+
+./main_rust:
+  test inp_low: .00254 sec
+  test inp_mid: .15996 sec
+  test inp_hi: 1.83357 sec
+
+Test 8_3_8
+
+Compiling programs..
+Generate test data..
+Measuring performance..
+../common/compare_performance.sh
+Averaging performance of 10 runs..
+./main_cpp:
+  test inp_low: .00405 sec
+  test inp_mid: .01352 sec
+  test inp_hi: .04957 sec
+
+./main_rust:
+  test inp_low: .00410 sec
+  test inp_mid: .01416 sec
+  test inp_hi: .05289 sec
+```

binary_search/Makefile

@@ -0,0 +1,8 @@
+include ../common/common.make
+
+gen:
+	cd ./generator;\
+	echo "10000 1000 0.5"       | cargo run > ../inp_low;\
+	echo "1000000 100000 0.5"   | cargo run > ../inp_mid;\
+	echo "10000000 1000000 0.5" | cargo run > ../inp_hi;\
+	cd ..

binary_search/README.md

@@ -0,0 +1,23 @@
+# Binary search
+
+## Problem description
+
+For the given arrays `A` and `B` print index `j` that is `A[j] = B[i]` for
+every `i`, or `-1` if `B[i]` is not found in the `A`.  The first line contains
+`n`, which is number of elements in `A`. And `n` integer numbers, which is
+`A`'s elements. The second line containes the same information for `B` array.
+
+```
+Sample Input:
+5 1 5 8 12 13
+5 8 1 23 1 11
+
+Sample Output:
+3 1 -1 1 -1
+```
+
+The original problem was taken form: https://stepik.org/lesson/13246/step/4
+
+## Note
+
+If A contains several elements with the same value, we should find any of them.

binary_search/generator/Cargo.lock

@@ -0,0 +1,7 @@
+[package]
+name = "generator"
+version = "0.1.0"
+authors = ["Dmitry Khominich"]
+
+[dependencies]
+rand = "*"

binary_search/generator/Cargo.toml

@@ -0,0 +1,46 @@
+extern crate rand;
+use std::io;
+use rand::Rng;
+
+
+fn read_line() -> String {
+    let mut line = String::new();
+    io::stdin().read_line(&mut line).unwrap();
+    line.trim().to_string()
+}
+
+fn main() {
+    let line = read_line();
+    let mut iter = line.split_whitespace();
+    // A size
+    let n: usize = iter.next().unwrap().parse().unwrap();
+    // B size
+    let k: usize = iter.next().unwrap().parse().unwrap();
+    // Uniform probabily that B[i] is in A
+    let pr: f64 = iter.next().unwrap().parse().unwrap();
+
+    let mut a_vec: Vec<u32> = vec![0; n];
+    let mut b_vec: Vec<u32> = vec![0; k];
+    for a in &mut a_vec {
+        *a = rand::thread_rng().gen_range(1, 1_000_000_000);
+    }
+    for b in &mut b_vec {
+        let chance: f64 = rand::thread_rng().gen_range(0.0, 1.0);
+        *b = if chance <= pr {
+                a_vec[rand::thread_rng().gen_range(0, n)]
+            } else {
+                rand::thread_rng().gen_range(1, 1_000_000_000)
+            }
+    }
+    print!("{}", n);
+    for a in a_vec {
+        print!(" {}", a);
+    }
+    println!("");
+
+    print!("{}", k);
+    for b in b_vec {
+        print!(" {}", b);
+    }
+    println!("");
+}

binary_search/generator/src/main.rs

@@ -0,0 +1,52 @@
+#include <cassert>
+#include <iostream>
+#include <vector>
+#include <algorithm>
+
+// return position of the element if found (indexing from 1),
+// return -1 otherwise
+template<typename T>
+int binary_search(std::vector<T> const& vec, T const& value) {
+    int l = 0;
+    int r = static_cast<int>(vec.size() - 1);
+    int i;
+    while(l <= r) {
+        i = int((l + r) / 2);
+        if(vec[i] == value) {
+            return i + 1;
+        } else if(vec[i] > value) {
+            r = i - 1;
+        } else if(vec[i] < value) {
+            l = i + 1;
+        }
+    }
+    return -1;
+}
+
+// read number of elements, read elements into vector
+std::vector<int> read_vec_w_num() {
+    size_t n;
+    std::cin >> n;
+    std::vector<int> vec(n, 0);
+    for (auto& val: vec)
+        std::cin >> val;
+    return vec;
+}
+
+int main(int argc, char** argv) {
+    std::ios::sync_with_stdio(false);
+
+    // 1. Read the array, and values for search
+    auto a_vec = read_vec_w_num();
+    auto const b_vec = read_vec_w_num();
+
+    // 2. Sort the array
+    std::sort(std::begin(a_vec), std::end(a_vec));
+
+    // 3. Search values, write results
+    for (auto const& val: b_vec)
+        std::cout << binary_search(a_vec, val) << " ";
+
+    return 0;
+}
+