Artemis: Proposed changes for increased performance

src/algorithms/primes.cc

@@ -10,7 +10,13 @@ Primes::IsPrime(int n) {
   if (n <= 1) {
     return false;
   }
-  for (int i = 2; i < n; i += 1) {
+  if (n == 2) {
+    return true;
+  }
+  if (n % 2 == 0) {
+    return false;
+  }
+  for (int i = 3; i * i <= n; i += 2) {
     if (n % i == 0) {
       return false;
     }
@@ -51,4 +57,4 @@ Primes::PrimeFactors(int n) {
     }
   }
   return factors;
-}
+}

src/algorithms/sort.cc

@@ -21,18 +21,17 @@ Sort::SortVector(std::vector<int> &v) {
 void
 Sort::DutchFlagPartition(std::vector<int> &v, int pivot_value) {
   int next_value = 0;
+  int size = v.size();
 
-  for (int i = 0; i < (int) v.size(); i += 1) {
+  for (int i = 0; i < size; ++i) {
     if (v[i] < pivot_value) {
-      std::swap(v[i], v[next_value]);
-      next_value += 1;
+      std::swap(v[i], v[next_value++]);
     }
   }
 
-  for (int i = next_value; i < (int) v.size(); i += 1) {
+  for (int i = next_value; i < size; ++i) {
     if (v[i] == pivot_value) {
-      std::swap(v[i], v[next_value]);
-      next_value += 1;
+      std::swap(v[i], v[next_value++]);
     }
   }
 }
@@ -47,14 +46,11 @@ Sort::DutchFlagPartition(std::vector<int> &v, int pivot_value) {
 std::vector<int>
 Sort::MaxN(std::vector<int> &v, int n) {
   std::vector<int> ret;
-  // So that we don't modify the original vector
   std::vector<int> temp(v);
 
-  std::sort(temp.begin(), temp.end());
+  std::partial_sort(temp.begin(), temp.begin() + n, temp.end(), std::greater<int>());
 
-  for (int i = (int) temp.size() - 1; i >= (int) temp.size() - n; i -= 1) {
-    ret.push_back(temp[i]);
-  }
+  ret.assign(temp.begin(), temp.begin() + n);
 
   return ret;
-}
+}

src/control/double.cc

@@ -10,11 +10,7 @@ long
 DoubleForLoop::SumSquare(int n) {
   long sum = 0;
   for (int i = 0; i < n; i += 1) {
-    for (int j = 0; j < n; j += 1) {
-      if (i == j) {
-        sum = sum + (long) (i * j);
-      }
-    }
+    sum += (long) (i * i);
   }
   return sum;
 }
@@ -29,9 +25,7 @@ long
 DoubleForLoop::SumTriangle(int n) {
   long sum = 0;
   for (int i = 0; i < n + 1; i += 1) {
-    for (int j = 0; j < i; j += 1) {
-      sum = sum + (long) j;
-    }
+    sum += (i - 1) * i / 2;
   }
   return sum;
 }
@@ -72,11 +66,10 @@ DoubleForLoop::CountPairs(std::vector<int> v) {
 int
 DoubleForLoop::CountDuplicates(std::vector<int> v0, std::vector<int> v1) {
   int count = 0;
-  for (int i = 0; i < (int) v0.size(); i += 1) {
-    for (int j = 0; j < (int) v1.size(); j += 1) {
-      if (i == j && v0[i] == v1[j]) {
-        count += 1;
-      }
+  int minSize = std::min(v0.size(), v1.size());
+  for (int i = 0; i < minSize; i += 1) {
+    if (v0[i] == v1[i]) {
+      count += 1;
     }
   }
   return count;
@@ -98,4 +91,4 @@ DoubleForLoop::SumMatrix(std::vector<std::vector<int>> matrix) {
     }
   }
   return sum;
-}
+}

src/control/single.cc

@@ -8,13 +8,9 @@
  */
 int
 SingleForLoop::SumRange(int n) {
-  int array[n];
   int sum = 0;
   for (int i = 0; i < n; i += 1) {
-    array[i] = i;
-  }
-  for (int i = 0; i < n; i += 1) {
-    sum += array[i];
+    sum += i;
   }
   return sum;
 }
@@ -50,15 +46,11 @@ SingleForLoop::MaxVector(std::vector<int> &arr) {
  */
 int
 SingleForLoop::SumModulus(int n, int m) {
-  int array[n];
   int sum = 0;
   for (int i = 0; i < n; i += 1) {
-    array[i] = i;
-  }
-  for (int i = 0; i < n; i += 1) {
-    if (array[i] % m == 0) {
-      sum += array[i];
+    if (i % m == 0) {
+      sum += i;
     }
   }
   return sum;
-}
+}

src/datastructures/linkedlist.cc

@@ -92,8 +92,8 @@ LinkedList::SearchList(int n) {
 /** @brief Reverses the linked list
  *
  */
-void
-LinkedList::ReverseList() {
+
+ void LinkedList::ReverseList() {
   Node *current = head;
   Node *prev = nullptr;
   Node *next = nullptr;
@@ -116,8 +116,8 @@ LinkedList::ReverseList() {
 int
 LinkedList::At(int n) {
   Node *current = head;
-  for (int i = 0; i < n; i += 1) {
+  while (n--) {
     current = current->next;
   }
   return current->data;
-}
+}

src/datastructures/vector.cc

@@ -59,8 +59,8 @@ std::vector<int>
 OpsVector::SortVector(std::vector<int> &v) {
   std::vector<int> ret(v);
 
-  for (int i = 0; i < (int) ret.size(); i += 1) {
-    for (int j = 0; j < (int) ret.size() - 1; j += 1) {
+  for (int i = 0; i < (int) ret.size() - 1; i += 1) {
+    for (int j = 0; j < (int) ret.size() - i - 1; j += 1) {
       if (ret[j] > ret[j + 1]) {
         int temp = ret[j];
         ret[j] = ret[j + 1];
@@ -126,4 +126,4 @@ OpsVector::MergeVectors(std::vector<int> &v1, std::vector<int> &v2) {
   }
 
   return ret;
-}
+}

src/math/vectoralgebra.cc

@@ -12,13 +12,15 @@
  *
  * @return Vector of y values (output)
  */
-std::vector<double>
-MathVectorAlgebra::Cubic(int a, int b, int c, int d, std::vector<double> &x) {
+
+ std::vector<double> MathVectorAlgebra::Cubic(int a, int b, int c, int d, std::vector<double> &x) {
   int n = x.size();
-  std::vector<double> y = std::vector<double>(n);
+  std::vector<double> y(n);
+
   for (int i = 0; i < n; i += 1) {
     y[i] = a * x[i] * x[i] * x[i] + b * x[i] * x[i] + c * x[i] + d;
   }
+
   return y;
 }
 
@@ -36,20 +38,17 @@ std::vector<double>
 MathVectorAlgebra::Convolve(int offset, std::vector<double> &h, std::vector<double> &x) {
   int m = h.size();
   int n = x.size();
-  int sum_h = 0;
-  std::vector<double> y = std::vector<double>(n);
-  for (int i = 0; i < m; i += 1) {
+  double sum_h = 0;
+  std::vector<double> y(n, 0.0);
+  for (int i = 0; i < m; ++i) {
     sum_h += std::abs(h[i]);
   }
   if (sum_h == 0) {
     sum_h = 1;
   }
-  for (int i = 0; i < n; i += 1) {
-    y[i] = 0;
-    for (int j = 0; j < m; j += 1) {
-      if (i - offset + j >= 0 && i - offset + j < n) {
-        y[i] += h[j] * x[i - offset + j] / sum_h;
-      }
+  for (int i = 0; i < n; ++i) {
+    for (int j = std::max(0, offset - i); j < std::min(m, n - i + offset); ++j) {
+      y[i] += h[j] * x[i - offset + j] / sum_h;
     }
   }
   return y;