version 5.1.0

Author: anderspkd

CMakeLists.txt

@@ -16,7 +16,7 @@
 
 cmake_minimum_required( VERSION 3.14 )
 
-project( scl VERSION 4.0.0 DESCRIPTION "Secure Computation Library" )
+project( scl VERSION 5.1.0 DESCRIPTION "Secure Computation Library" )
 
 if(NOT CMAKE_BUILD_TYPE)
   set(CMAKE_BUILD_TYPE Release)
@@ -47,8 +47,6 @@ set(SCL_SOURCE_FILES
   src/scl/net/mem_channel.cc
   src/scl/net/threaded_sender.cc
   src/scl/net/network.cc
-  src/scl/net/discovery/server.cc
-  src/scl/net/discovery/client.cc
 
   src/scl/simulation/simulator.cc
   src/scl/simulation/simulate_recv_time.cc
@@ -123,7 +121,6 @@ if(CMAKE_BUILD_TYPE MATCHES "Debug")
     test/scl/net/test_tcp_channel.cc
     test/scl/net/test_threaded_sender.cc
     test/scl/net/test_network.cc
-    test/scl/net/test_discover.cc
     test/scl/net/test_shared_deque.cc
     test/scl/net/test_channel.cc
 

RELEASE.txt

@@ -1,3 +1,7 @@
+5.1: Vec-Mat multiplication
+- Add a Vec Mat to Vec multiplication function to Mat
+- Minor refactoring of test_mat.cc
+
 5.0: Simulation
 - Added a new module for simulating protocol executions under different network
   conditions.

include/scl/math/mat.h

@@ -28,6 +28,7 @@
 #include <vector>
 
 #include "scl/math/lagrange.h"
+#include "scl/math/vec.h"
 #include "scl/util/prg.h"
 #include "scl/util/traits.h"
 
@@ -311,6 +312,17 @@ class Mat {
    */
   Mat Multiply(const Mat& other) const;
 
+  /**
+   * @brief Performs a matrix vector product.
+   * @param vector the vector.
+   * @return the result vector.
+   *
+   * This computes \f$A\cdot x\f$ where \f$A\f$ is a \f$n\times m\f$ matrix and
+   * \f$x\f$ a length \f$m\f$ vector. The return value is a vector \f$y\f$ of
+   * length \f$n\f$.
+   */
+  Vec<Elem> Multiply(const Vec<Elem>& vector) const;
+
   /**
    * @brief Multiply this matrix with a scalar
    * @param scalar the scalar
@@ -498,7 +510,7 @@ Mat<Elem> Mat<Elem>::HyperInvertible(std::size_t n, std::size_t m) {
 template <typename Elem>
 Mat<Elem> Mat<Elem>::Multiply(const Mat<Elem>& other) const {
   if (Cols() != other.Rows()) {
-    throw std::invalid_argument("invalid matrix dimensions for multiply");
+    throw std::invalid_argument("matmul: this->Cols() != that->Rows()");
   }
   const auto n = Rows();
   const auto p = Cols();
@@ -515,6 +527,24 @@ Mat<Elem> Mat<Elem>::Multiply(const Mat<Elem>& other) const {
   return result;
 }  // LCOV_EXCL_LINE
 
+template <typename Elem>
+Vec<Elem> Mat<Elem>::Multiply(const Vec<Elem>& vector) const {
+  if (Cols() != vector.Size()) {
+    throw std::invalid_argument("matmul: this->Cols() != vec.Size()");
+  }
+
+  std::vector<Elem> result;
+  result.reserve(Rows());
+
+  for (std::size_t i = 0; i < Rows(); ++i) {
+    auto b = mValues.begin() + i * Cols();
+    auto e = mValues.begin() + (i + 1) * Cols();
+    result.emplace_back(UncheckedInnerProd<Elem>(b, e, vector.begin()));
+  }
+
+  return result;
+}
+
 template <typename Elem>
 Mat<Elem> Mat<Elem>::Transpose() const {
   Mat t(Cols(), Rows());

test/scl/math/test_mat.cc

@@ -26,10 +26,11 @@ using namespace scl;
 
 using FF = math::Fp<61>;
 using Mat = math::Mat<FF>;
+using Vec = math::Vec<FF>;
 
 namespace {
 
-void Populate(Mat& m, const int* values) {
+void Populate(Mat& m, const std::vector<int>& values) {
   for (std::size_t i = 0; i < m.Rows(); i++) {
     for (std::size_t j = 0; j < m.Cols(); j++) {
       m(i, j) = FF(values[i * m.Cols() + j]);
@@ -41,11 +42,9 @@ void Populate(Mat& m, const int* values) {
 
 TEST_CASE("Matrix construction", "[math][matrix]") {
   Mat m0(2, 2);
-  int v0[] = {1, 2, 5, 6};
-  Populate(m0, v0);
+  Populate(m0, {1, 2, 5, 6});
   Mat m1(2, 2);
-  int v1[] = {4, 3, 2, 1};
-  Populate(m1, v1);
+  Populate(m1, {4, 3, 2, 1});
 
   REQUIRE(!m0.Equals(m1));
   REQUIRE(m0.Rows() == 2);
@@ -100,8 +99,7 @@ TEST_CASE("Matrix construction from Vec", "[math][matrix]") {
 
 TEST_CASE("Matrix mutation", "[math][matrix]") {
   Mat m0(2, 2);
-  int v0[] = {1, 2, 5, 6};
-  Populate(m0, v0);
+  Populate(m0, {1, 2, 5, 6});
 
   auto m = m0;
   m(0, 1) = FF(100);
@@ -111,8 +109,7 @@ TEST_CASE("Matrix mutation", "[math][matrix]") {
 
 TEST_CASE("Matrix ToString", "[math][matrix]") {
   Mat m(3, 2);
-  int v[] = {1, 2, 44444, 5, 6, 7};
-  Populate(m, v);
+  Populate(m, {1, 2, 44444, 5, 6, 7});
   std::string expected =
       "\n"
       "[    1  2 ]\n"
@@ -130,11 +127,9 @@ TEST_CASE("Matrix ToString", "[math][matrix]") {
 
 TEST_CASE("Matrix Addition", "[math][matrix]") {
   Mat m0(2, 2);
-  int v0[] = {1, 2, 5, 6};
-  Populate(m0, v0);
+  Populate(m0, {1, 2, 5, 6});
   Mat m1(2, 2);
-  int v1[] = {4, 3, 2, 1};
-  Populate(m1, v1);
+  Populate(m1, {4, 3, 2, 1});
 
   auto m2 = m0.Add(m1);
   REQUIRE(m2.Rows() == 2);
@@ -149,11 +144,9 @@ TEST_CASE("Matrix Addition", "[math][matrix]") {
 
 TEST_CASE("Matrix Subtraction", "[math][matrix]") {
   Mat m0(2, 2);
-  int v0[] = {1, 2, 5, 6};
-  Populate(m0, v0);
+  Populate(m0, {1, 2, 5, 6});
   Mat m1(2, 2);
-  int v1[] = {4, 3, 2, 1};
-  Populate(m1, v1);
+  Populate(m1, {4, 3, 2, 1});
 
   auto m2 = m0.Subtract(m1);
   REQUIRE(m2(0, 0) == FF(1) - FF(4));
@@ -166,11 +159,9 @@ TEST_CASE("Matrix Subtraction", "[math][matrix]") {
 
 TEST_CASE("Matrix MultiplyEntryWise", "[math][matrix]") {
   Mat m0(2, 2);
-  int v0[] = {1, 2, 5, 6};
-  Populate(m0, v0);
+  Populate(m0, {1, 2, 5, 6});
   Mat m1(2, 2);
-  int v1[] = {4, 3, 2, 1};
-  Populate(m1, v1);
+  Populate(m1, {4, 3, 2, 1});
 
   auto m2 = m0.MultiplyEntryWise(m1);
   REQUIRE(m2(0, 0) == FF(4));
@@ -183,11 +174,9 @@ TEST_CASE("Matrix MultiplyEntryWise", "[math][matrix]") {
 
 TEST_CASE("Matrix Multiply", "[math][matrix]") {
   Mat m0(2, 2);
-  int v0[] = {1, 2, 5, 6};
-  Populate(m0, v0);
+  Populate(m0, {1, 2, 5, 6});
   Mat m1(2, 2);
-  int v1[] = {4, 3, 2, 1};
-  Populate(m1, v1);
+  Populate(m1, {4, 3, 2, 1});
 
   auto m2 = m0.Multiply(m1);
   REQUIRE(m2.Rows() == 2);
@@ -198,32 +187,45 @@ TEST_CASE("Matrix Multiply", "[math][matrix]") {
   REQUIRE(m2(1, 1) == FF(21));
 
   Mat m3(2, 10);
-  int v3[] = {1,  2,  3,  4,  5,  6,  7,  8,  9,  0,
-              11, 12, 13, 14, 15, 16, 17, 18, 19, 20};
-  Populate(m3, v3);
+  Populate(m3, {1,  2,  3,  4,  5,  6,  7,  8,  9,  0,
+                11, 12, 13, 14, 15, 16, 17, 18, 19, 20});
 
   auto m5 = m0.Multiply(m3);
   REQUIRE(m5.Rows() == 2);
   REQUIRE(m5.Cols() == 10);
   Mat m4(2, 10);
-  int v4[] = {23, 26, 29, 32,  35,  38,  41,  44,  47,  40,
-              71, 82, 93, 104, 115, 126, 137, 148, 159, 120};
-  Populate(m4, v4);
+  Populate(m4, {23, 26, 29, 32,  35,  38,  41,  44,  47,  40,
+                71, 82, 93, 104, 115, 126, 137, 148, 159, 120});
   REQUIRE(m5.Equals(m4));
 
   REQUIRE_THROWS_MATCHES(
       m3.Multiply(m0),
       std::invalid_argument,
-      Catch::Matchers::Message("invalid matrix dimensions for multiply"));
+      Catch::Matchers::Message("matmul: this->Cols() != that->Rows()"));
+}
+
+TEST_CASE("Matrix vector multiply", "[math][matrix]") {
+  Mat m0(2, 3);
+  Populate(m0, {1, 2, 3, 4, 5, 6});
+  Vec v0 = {FF(1), FF(2), FF(3)};
+
+  Vec v1 = m0.Multiply(v0);
+  REQUIRE(v1.Size() == 2);
+  REQUIRE(v1[0] == FF(1 * 1 + 2 * 2 + 3 * 3));
+  REQUIRE(v1[1] == FF(4 * 1 + 5 * 2 + 6 * 3));
+
+  Vec v2 = {FF(6), FF(7)};
+  REQUIRE_THROWS_MATCHES(
+      m0.Multiply(v2),
+      std::invalid_argument,
+      Catch::Matchers::Message("matmul: this->Cols() != vec.Size()"));
 }
 
 TEST_CASE("Matrix ScalarMultiply", "[math][matrix]") {
   Mat m0(2, 2);
-  int v0[] = {1, 2, 5, 6};
-  Populate(m0, v0);
+  Populate(m0, {1, 2, 5, 6});
   Mat m1(2, 2);
-  int v1[] = {4, 3, 2, 1};
-  Populate(m1, v1);
+  Populate(m1, {4, 3, 2, 1});
 
   auto m2 = m0.ScalarMultiply(FF(2));
   REQUIRE(m2(0, 0) == FF(2));
@@ -240,8 +242,7 @@ TEST_CASE("Matrix ScalarMultiply", "[math][matrix]") {
 
 TEST_CASE("Matrix Transpose", "[math][matrix]") {
   Mat m3(2, 3);
-  int v3[] = {1, 2, 3, 11, 12, 13};
-  Populate(m3, v3);
+  Populate(m3, {1, 2, 3, 11, 12, 13});
   auto m4 = m3.Transpose();
   REQUIRE(m4.Rows() == m3.Cols());
   REQUIRE(m4.Cols() == m3.Rows());