first commit

Makefile

@@ -0,0 +1,20 @@
+all: insert search matrixMult nHighest sorting
+
+sorting: sorting.cpp
+	g++ -o sorting sorting.cpp -std=c++11
+
+nHighest: nHighest.cpp
+	g++ -o nHighest nHighest.cpp -std=c++11
+
+matrixMult: matrixMult.cpp
+	g++ -o matrixMult matrixMult.cpp -std=c++11
+
+search: search.cpp
+	g++ -o search search.cpp -std=c++11
+
+insert: insert.cpp
+	g++ -o insert insert.cpp -std=c++11
+
+
+clean: 
+	rm insert search matrixMult nHighest sorting

insert.cpp

@@ -0,0 +1,60 @@
+// Compare the execution times of inserting at the front vs. inserting
+// at the back of a vector.
+//
+// Usage:
+//    ./<exec name> <size of list>
+
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <algorithm>
+using namespace std;
+
+
+void insertManyFront(vector<int> & v, int size) {
+	for (int i = 0; i < size; i++) 
+    	v.insert(v.begin(), rand() % size);
+}
+
+void insertManyBack(vector<int> & v, int size) {
+	for (int i = 0; i < size; i++) 
+    	v.push_back(rand() % size);
+}
+
+int main(int argc, char *argv[]) {
+  
+  if (argc < 2) { 
+  	cout << "Usage: " << argv[0] << " <size> \n"; 
+    exit(1);
+  }
+  int size = atoi(argv[1]);
+  
+  vector<int> v,w;
+  
+  // initialize the random seed
+  srand(time(NULL));
+  
+  
+  double elapsed_secs;
+
+  // measure time to insert many elements in front
+  clock_t begin = clock();
+	insertManyFront(v, size);
+  clock_t end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "\nInsert at front elapsed: " << elapsed_secs << " seconds\n";
+  
+  // measure time to insert many elements in the back
+  begin = clock();
+  insertManyBack(w, size);
+  end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "Insert back elapsed: " << elapsed_secs << " seconds\n\n";
+  
+  return 0;
+}
+
+
+

matrixMult.cpp

@@ -0,0 +1,109 @@
+// Compare the execution times of multiplying a matrix by a vector vs
+// a matrix by a matrix.
+//
+// Usage:
+//    ./<exec name> <size of list>
+
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <algorithm>
+
+typedef unsigned int uint;
+using namespace std;
+
+const int SIZE = 20000;
+
+void vectorMatrixMult(const vector< vector <int> > & M, const vector<int> & y, vector<int> &res) {
+	res.resize(y.size());
+  for (int r = 0; r < M.size(); r++) {
+    	int sum = 0;
+    	for (int c = 0; c < y.size(); c++) {
+        	sum = sum + (M[r][c] * y[c]);
+        }
+      	res[r] = sum; 
+    }
+}
+
+void matrixMatrixMult(const vector< vector <int> > & A, 
+  const vector< vector <int> > & B, vector< vector <int> > & res) {
+  
+  res.resize(A.size());
+  for (auto &r: res) {
+    r.resize(B[0].size());
+  }
+
+  for (uint cb = 0; cb < B[0].size(); cb++) {
+    for (uint ra = 0; ra < A.size(); ra++) {
+      int sum = 0;
+      for (uint ca = 0; ca < A[0].size(); ca++) {
+        // printf("ra ca cb: %d %d %d\n",ra,ca,cb);
+          sum = sum + (A[ra][ca] * B[ca][cb]);
+      }
+      res[ra][cb] = sum; 
+    }
+  }
+}
+
+
+
+void fillMatrix(vector< vector <int> > & M, uint size) {
+  M.resize(size);
+  for (uint r = 0; r < size; r++) {
+    M[r].resize(size);	
+    for (uint c = 0; c < size; c++) {
+        	M[r][c] = rand() % size;
+        }
+    }	
+}
+
+void fillVector(vector<int> & V, int size) {
+  V.resize(size);
+  for (int r = 0; r < size; r++) {
+       V[r]= rand() % size;
+  }	
+}
+
+
+int main(int argc, char *argv[]) {
+  
+  if (argc < 2) { 
+  	cout << "Usage: " << argv[0] << " <size> \n"; 
+    exit(1);
+  }
+  int size = atoi(argv[1]);
+  
+  vector< vector<int> > M;
+  vector <int> x, y;
+  
+  srand(time(NULL));
+  
+  
+  fillMatrix(M,size);
+  fillVector(y,size);
+  
+
+  double elapsed_secs;
+
+  // measure vector matrix mult time
+  clock_t begin = clock();
+  vectorMatrixMult(M, y, x);
+  clock_t end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "\nTime elapsed for vector matrix mult: " << elapsed_secs << " seconds\n";
+  
+  // measure matrix matrix mult time
+  vector < vector <int> > R;
+  begin = clock();
+  matrixMatrixMult(M,M,R);
+  end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "Time elapsed for matrix matrix mult: " << elapsed_secs << " seconds\n\n";
+    
+  return 0;
+}
+
+
+

nHighest.cpp

@@ -0,0 +1,122 @@
+// Measure execution times of two algorithms for computing 
+// the 10 largest numbers in a list.
+// 
+// Must compile using the -std=c++11 option.
+//
+// Usage:
+//    ./<exec name> <size of list>
+
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <algorithm>
+#include <queue>
+
+using namespace std;
+
+//
+// Given a vector V and an integer n, copy the n largest 
+// numbers to rest.  This algorithm uses sorting.
+//
+void nHighest(vector <float> &V, int n, vector <float> &res) {
+  sort(V.begin(), V.end());
+  res.resize(n);
+  copy(V.begin()+V.size()-n, V.end(), res.begin());
+}
+
+
+//
+// Given a vector V and an integer n, copy the n largest 
+// numbers to rest.  This algorithm uses a priority queue.
+//
+void nHighestWithPQ(const vector <float> &V, int n, vector <float> &res) {
+  res.resize(0);
+  priority_queue<float, std::vector<float> , std::greater<float>> q;
+
+  // put the first n+1 elements into the queue
+  for (int i = 0; i <= n; i++) q.push(V[i]);
+  
+  // for the rest, if they are higher than the smallest in the queue,
+  // then enqueue
+  for (int i = n+1; i < V.size(); i++) {
+    if (V[i] > q.top()) {
+  	  q.pop();       // pop the 11th largest element
+      q.push(V[i]);  // push one element
+    }
+  }
+  q.pop();
+
+  while (!q.empty()) {
+    res.push_back(q.top());
+    q.pop();
+  }
+}
+
+
+
+int main(int argc, char *argv[]) {
+  
+  // get the command line argument
+  if (argc < 2) { 
+  	cout << "Usage: " << argv[0] << " <size> \n"; 
+    exit(1);
+  }
+  int size = atoi(argv[1]);
+  
+
+  vector<float> v,w;
+  
+    // fill the v vector with random integers
+  for (int i = 0; i < size; i++) 
+  	v.push_back(rand() / static_cast<float>(RAND_MAX));
+  
+  // copy v to w
+  w = v;
+  
+  // initialize the random seed
+  srand(time(NULL));
+  
+  vector<float> res1, res2;
+  
+  double elapsed_secs;
+
+  // measure the time for the sorting version
+  clock_t begin = clock();
+  nHighest(v, 10, res1);
+  clock_t end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "\nAlgorithm A: " << elapsed_secs << " seconds\n";
+
+  // measure the time for the priority queue version
+  begin = clock();
+  nHighestWithPQ(w, 10, res2);
+  end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "Algorithm B: " << elapsed_secs << " seconds\n";
+
+  #ifdef DEBUG  
+  cout << "Results for algorithm A:\n";
+  for (auto e: res1) cout << e <<" ";
+  cout << '\n';
+
+  cout << "Results for algorithm B:\n";
+  for (auto e: res1) cout << e <<" ";
+  cout << '\n';
+  #endif 
+  
+  if (res1 == res2) 
+    cout << "Congratulations. Both algorithms had the ame results!\n\n";
+  else              
+    cout << "Bad new. The algorithms obtained different results :-(\n";
+  
+  return 0;
+}
+
+//  125000
+//  250000
+//  500000
+// 1000000
+
+

search.cpp

@@ -0,0 +1,66 @@
+// Measure execution times of binary search and linear search
+// on a sorted list.
+//
+// Usage:
+//    ./<exec name> <size of list>
+
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <algorithm>
+using namespace std;
+
+int main(int argc, char *argv[]) {
+  
+  // get the command line arguments
+  if (argc < 2) { 
+  	cout << "Usage: " << argv[0] << " <size> \n"; 
+    exit(1);
+  }
+  int size = atoi(argv[1]);
+  
+  vector<int> v; 
+  
+  // fill the v vector with random integers and then sort
+  for (int i = 0; i < size; i++) v.push_back(rand());
+  
+  sort(v.begin(), v.end());
+  
+  // initialize the random seed
+  srand(time(NULL));
+  
+  int search_item;  
+  double elapsed_secs;
+
+  clock_t begin = clock();
+  
+  // do a 100k searches using binary search
+  for (int i = 0; i < 100000; i++) {
+    search_item = rand();
+    binary_search(v.begin(), v.end(), search_item );
+  }
+    
+  clock_t end = clock();
+
+  
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "\nBinary search: " << elapsed_secs << " seconds\n";
+  
+  begin = clock();
+  
+  // do 1000 searches using linear find. 
+  for (int i = 0; i < 1000; i++) {
+    search_item = rand();
+    find(v.begin(), v.end(), search_item);
+  }
+
+  end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "Linear search: " << elapsed_secs << " seconds\n\n";
+    
+  return 0;
+}
+
+
+

sorting.cpp

@@ -0,0 +1,77 @@
+// Measure execution times of bubble sort vs. the STL implementation
+// of sort.
+//
+// Usage:
+//    ./<exec name> <size of list>
+
+#include <iostream>
+#include <vector>
+#include <cstdlib>
+#include <algorithm>
+using namespace std;
+
+
+//
+// Given a vector if ints, bubble sort it.
+//
+void bubbleSort(vector<int> & arr) {
+  int i, j;
+  int n = arr.size();
+  for (i = 0; i < n-1; i++)  {    
+    // Last i elements are already in place   
+    for (j = 0; j < n-i-1; j++) {
+      if (arr[j] > arr[j+1])
+        swap(arr[j], arr[j+1]);
+    }
+  }
+}
+
+
+int main(int argc, char *argv[]) {
+  
+  if (argc < 2) { 
+  	cout << "Usage: " << argv[0] << " <size> \n"; 
+    exit(1);
+  }
+  int size = atoi(argv[1]);
+  
+  vector<int> v,w;
+  
+  // initialize the random seed
+  srand(time(NULL));
+  
+  // fill the v vector with random integers
+  for (unsigned int i = 0; i < size; i++) 
+  	v.push_back(rand() % size);
+  
+  // copy v to w
+  w = v;
+  
+  double elapsed_secs;
+
+  // measure time to bubble sort
+  clock_t begin = clock();
+  bubbleSort(v);
+  clock_t end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "\nTime elapsed for Bubblesort: " << elapsed_secs << " seconds\n";
+  
+  // measure time to sort using the STL sort algorithm
+  begin = clock();
+  sort(w.begin(),w.end());
+  end = clock();
+
+  elapsed_secs = static_cast<double>(end - begin) / CLOCKS_PER_SEC;
+  cout << "Time elapsed for STL sort: " << elapsed_secs << " seconds\n";
+  
+  if ( is_sorted(v.begin(),v.end()) && is_sorted(w.begin(),w.end()) ) 
+    cout << "Congrats! Both vectors were properly sorted!\n\n";
+  else 
+    cout << "At least one of the algorithms returned an unsorted vector.\n\n"; 
+  
+  return 0;
+}
+
+
+