more benchmarks, in fewer files. done for now!

benchmark/src/Crypto.cpp

@@ -53,8 +53,8 @@ using namespace std;
 using namespace lbcrypto;
 
 #include "vechelper.h"
-#include "ElementParmsHelper.h"
 #include "EncryptHelper.h"
+#include "lattice/elemparamfactory.h"
 
 void BM_keygen(benchmark::State& state) { // benchmark
 	CryptoContext<Poly> cc;

benchmark/src/ElementParmsHelper.h

-/**
- * @author  TPOC: palisade@njit.edu
- *
- * @copyright Copyright (c) 2017, New Jersey Institute of Technology (NJIT)
- * All rights reserved.
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice, this
- * list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice, this
- * list of conditions and the following disclaimer in the documentation and/or other
- * materials provided with the distribution.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-
-#include "lattice/elemparamfactory.h"
-
-shared_ptr<ILParams> parm_16 = ElemParamFactory::GenElemParams<ILParams>(M16);
-shared_ptr<ILParams> parm_1024 = ElemParamFactory::GenElemParams<ILParams>(M1024);
-shared_ptr<ILParams> parm_2048 = ElemParamFactory::GenElemParams<ILParams>(M2048);
-shared_ptr<ILParams> parm_4096 = ElemParamFactory::GenElemParams<ILParams>(M4096);
-shared_ptr<ILParams> parm_8192 = ElemParamFactory::GenElemParams<ILParams>(M8192);
-shared_ptr<ILParams> parm_16384 = ElemParamFactory::GenElemParams<ILParams>(M16384);
-shared_ptr<ILParams> parm_32768 = ElemParamFactory::GenElemParams<ILParams>(M32768);
-
-shared_ptr<ILParams> parmArray[] = {
-parm_16,
-parm_1024,
-parm_2048,
-parm_4096,
-parm_8192,
-parm_16384,
-parm_32768,
-};
-
-shared_ptr<ILNativeParams> nparm_16 = ElemParamFactory::GenElemParams<ILNativeParams>(M16);
-shared_ptr<ILNativeParams> nparm_1024 = ElemParamFactory::GenElemParams<ILNativeParams>(M1024);
-shared_ptr<ILNativeParams> nparm_2048 = ElemParamFactory::GenElemParams<ILNativeParams>(M2048);
-shared_ptr<ILNativeParams> nparm_4096 = ElemParamFactory::GenElemParams<ILNativeParams>(M4096);
-
-shared_ptr<ILNativeParams> nparmArray[] = {
-nparm_16,
-nparm_1024,
-nparm_2048,
-nparm_4096,
-//nparm_8192,
-//nparm_16384,
-//nparm_32768,
-};
-
-#define DO_PARM_BENCHMARK(X) \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("parm_16")->Arg(0); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("parm_1024")->Arg(1); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("parm_2048")->Arg(2); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("parm_4096")->Arg(3); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("parm_8192")->Arg(4); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("parm_16384")->Arg(5); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("parm_32768")->Arg(6);
-
-#define DO_NATIVEPARM_BENCHMARK(X) \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("nparm_16")->Arg(0); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("nparm_1024")->Arg(1); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("nparm_2048")->Arg(2); \
-BENCHMARK(X)->Unit(benchmark::kMicrosecond)->ArgName("nparm_4096")->Arg(3); 
-
-
-#define DO_PARM_BENCHMARK_TEMPLATE(X,Y) \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_16")->Arg(0); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_1024")->Arg(1); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_2048")->Arg(2); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_4096")->Arg(3); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_8192")->Arg(4); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_16384")->Arg(5); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_32768")->Arg(6);
-
-#define DO_NATIVEPARM_BENCHMARK_TEMPLATE(X,Y) \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("nparm_16")->Arg(0); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("nparm_1024")->Arg(1); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("nparm_2048")->Arg(2); \
-		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("nparm_4096")->Arg(3); 
-

benchmark/src/Lattice.cpp

@@ -36,7 +36,6 @@
 #include <vector>
 
 #include "vechelper.h"
-#include "ElementParmsHelper.h"
 
 #include "lattice/elemparams.cpp"
 #include "lattice/ilparams.cpp"
@@ -47,13 +46,14 @@
 #include "math/transfrm.cpp"
 #include "math/discreteuniformgenerator.cpp"
 #include "math/discretegaussiangenerator.cpp"
+#include "lattice/elemparamfactory.h"
 
 using namespace std;
 using namespace lbcrypto;
 
 template <typename E>
 static E makeElement(shared_ptr<lbcrypto::ILParamsImpl<typename E::Integer>> params) {
-	typename E::Vector	vec = makeVector<E>(params);
+	typename E::Vector	vec = makeVector<typename E::Vector>(params->GetRingDimension(), params->GetModulus());
 	E					elem(params);
 
 	elem.SetValues(vec, elem.GetFormat());
@@ -63,7 +63,7 @@ static E makeElement(shared_ptr<lbcrypto::ILParamsImpl<typename E::Integer>> par
 template <typename E>
 static E makeElement(shared_ptr<lbcrypto::ILDCRTParams<typename E::Integer>> p) {
 	shared_ptr<ILParamsImpl<typename E::Integer>>	params( new ILParamsImpl<typename E::Integer>( p->GetCyclotomicOrder(), p->GetModulus(), 1) );
-	typename E::Vector								vec = makeVector<typename E::PolyLargeType>(params);
+	typename E::Vector	vec = makeVector<typename E::Vector>(params->GetRingDimension(), params->GetModulus());
 
 	typename E::PolyLargeType	bigE(params);
 	bigE.SetValues(vec, bigE.GetFormat());

benchmark/src/NativeVectorMath.cpp

-/*
- * @author  TPOC: palisade@njit.edu
- *
- * @copyright Copyright (c) 2017, New Jersey Institute of Technology (NJIT)
- * All rights reserved.
- * Redistribution and use in source and binary forms, with or without modification,
- * are permitted provided that the following conditions are met:
- * 1. Redistributions of source code must retain the above copyright notice, this
- * list of conditions and the following disclaimer.
- * 2. Redistributions in binary form must reproduce the above copyright notice, this
- * list of conditions and the following disclaimer in the documentation and/or other
- * materials provided with the distribution.
- * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
- * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
- * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
- * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
- * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
- * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
- * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
- * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN
- * IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
- *
- */
-/*
-  This code benchmarks functions of the math directory  of the PALISADE lattice encryption library.
-
-*/
-#include "benchmark/benchmark_api.h"
-
-#include <iostream>
-#define _USE_MATH_DEFINES
-#include "math/backend.h"
-#include "utils/inttypes.h"
-#include "math/nbtheory.h"
-#include "lattice/elemparams.h"
-#include "lattice/ilparams.h"
-#include "lattice/ildcrtparams.h"
-#include "lattice/ilelement.h"
-#include "math/distrgen.h"
-#include "lattice/poly.h"
-#include "../../src/core/lib/lattice/dcrtpoly.h"
-#include "utils/utilities.h"
-
-#include "vechelper.h"
-#include "ElementParmsHelper.h"
-
-using namespace std;
-using namespace lbcrypto;
-
-// add
-static void add_BBVNative(benchmark::State& state) {
-	state.PauseTiming();
-	NativeVector a = makeNativeVector(nparmArray[state.range(0)]);
-	NativeVector b = makeNativeVector(nparmArray[state.range(0)]);
-	state.ResumeTiming();
-
-	a = a+b;
-}
-
-static void BM_BBVNative_Addition(benchmark::State& state) { // benchmark
-
-	while (state.KeepRunning()) {
-		add_BBVNative(state);
-	}
-}
-
-DO_NATIVEPARM_BENCHMARK(BM_BBVNative_Addition)
-
-// +=
-static void addeq_BBVNative(benchmark::State& state) {
-	state.PauseTiming();
-	NativeVector a = makeNativeVector(nparmArray[state.range(0)]);
-	NativeVector b = makeNativeVector(nparmArray[state.range(0)]);
-	state.ResumeTiming();
-
-	a += b;
-}
-
-static void BM_BBVNative_AddEq(benchmark::State& state) { // benchmark
-
-	while (state.KeepRunning()) {
-		addeq_BBVNative(state);
-	}
-}
-
-DO_NATIVEPARM_BENCHMARK(BM_BBVNative_AddEq)
-
-// mult
-static void mult_BBVNative(benchmark::State& state) {	// function
-	state.PauseTiming();
-	NativeVector a = makeNativeVector(nparmArray[state.range(0)]);
-	NativeVector b = makeNativeVector(nparmArray[state.range(0)]);
-	state.ResumeTiming();
-
-	a = a*b;
-}
-
-static void BM_BBVNative_Multiplication(benchmark::State& state) { // benchmark
-
-	while (state.KeepRunning()) {
-		mult_BBVNative(state);
-	}
-}
-
-DO_NATIVEPARM_BENCHMARK(BM_BBVNative_Multiplication)
-
-// *=
-static void multeq_BBVNative(benchmark::State& state) {	// function
-	state.PauseTiming();
-	NativeVector a = makeNativeVector(nparmArray[state.range(0)]);
-	NativeVector b = makeNativeVector(nparmArray[state.range(0)]);
-	state.ResumeTiming();
-
-	a *= b;
-}
-
-static void BM_BBVNative_MultEq(benchmark::State& state) { // benchmark
-
-	while (state.KeepRunning()) {
-		multeq_BBVNative(state);
-	}
-}
-
-DO_NATIVEPARM_BENCHMARK(BM_BBVNative_MultEq)
-
-//execute the benchmarks
-BENCHMARK_MAIN()

benchmark/src/SHE.cpp

@@ -41,7 +41,7 @@
 using namespace std;
 using namespace lbcrypto;
 
-static std::vector<int64_t> makeVector(int siz, const PlaintextModulus& ptmi) {
+static std::vector<int64_t> makeIntVector(int siz, const PlaintextModulus& ptmi) {
 	std::vector<int64_t>			elem;
 	PlaintextModulus half = ptmi/2;
 
@@ -57,8 +57,8 @@ static bool setup_SHE(CryptoContext<Poly> cc, Ciphertext<Poly>& ct1, Ciphertext<
 
 	LPKeyPair<Poly> kp = cc->KeyGen();
 
-	Plaintext p1 = cc->MakeCoefPackedPlaintext( makeVector(nel, ptm) );
-	Plaintext p2 = cc->MakeCoefPackedPlaintext( makeVector(nel, ptm) );
+	Plaintext p1 = cc->MakeCoefPackedPlaintext( makeIntVector(nel, ptm) );
+	Plaintext p2 = cc->MakeCoefPackedPlaintext( makeIntVector(nel, ptm) );
 
 	ct1 = cc->Encrypt(kp.publicKey, p1);
 	ct2 = cc->Encrypt(kp.publicKey, p2);

benchmark/src/BigVectorMath.cpp → benchmark/src/VectorMath.cpp

@@ -32,86 +32,130 @@
 #include <iostream>
 
 #include "vechelper.h"
-#include "ElementParmsHelper.h"
+
+#include "lattice/elemparams.cpp"
+#include "lattice/ilparams.cpp"
+#include "lattice/ildcrtparams.cpp"
+#include "lattice/poly.cpp"
+#include "lattice/dcrtpoly.cpp"
+#include "math/nbtheory.cpp"
+#include "math/transfrm.cpp"
+#include "math/discreteuniformgenerator.cpp"
+#include "math/discretegaussiangenerator.cpp"
+#include "lattice/elemparamfactory.h"
 
 using namespace std;
 using namespace lbcrypto;
 
-// add
-static void add_BigVec(benchmark::State& state) {
-	state.PauseTiming();
-	BigVector a = makeVector<Poly>(parmArray[state.range(0)]);
-	BigVector b = makeVector<Poly>(parmArray[state.range(0)]);
-	state.ResumeTiming();
+#define DO_NATIVEVECTOR_BENCHMARK(X) \
+		BENCHMARK_TEMPLATE(X,NativeVector)->Unit(benchmark::kMicrosecond)->ArgName("parm_16")->Arg(16); \
+		BENCHMARK_TEMPLATE(X,NativeVector)->Unit(benchmark::kMicrosecond)->ArgName("parm_1024")->Arg(1024); \
+		BENCHMARK_TEMPLATE(X,NativeVector)->Unit(benchmark::kMicrosecond)->ArgName("parm_2048")->Arg(2048);
 
-	a = a+b;
+#define DO_VECTOR_BENCHMARK_TEMPLATE(X,Y) \
+		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_16")->Arg(16); \
+		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_1024")->Arg(1024); \
+		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_2048")->Arg(2048); \
+		/*BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_4096")->Arg(4096);*/ \
+		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_8192")->Arg(8192); \
+		/*BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_16384")->Arg(16384);*/ \
+		BENCHMARK_TEMPLATE(X,Y)->Unit(benchmark::kMicrosecond)->ArgName("parm_32768")->Arg(32768);
+
+// add
+template <typename V>
+static void add_BigVec(const V& a, const V& b) {
+	V c = a+b;
 }
 
-static void BM_BigVec_Addition(benchmark::State& state) { // benchmark
+template <typename V>
+static void BM_BigVec_Add(benchmark::State& state) { // benchmark
+	auto p = state.range(0);
+	size_t idx = ElemParamFactory::GetNearestIndex(p);
+	typename V::Integer q( ElemParamFactory::DefaultSet[idx].q);
+	V a = makeVector<V>(p, q);
+	V b = makeVector<V>(p, q);
 
 	while (state.KeepRunning()) {
-		add_BigVec(state);
+		add_BigVec<V>(a,b);
 	}
 }
 
-DO_PARM_BENCHMARK(BM_BigVec_Addition)
+DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Add)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Add, BE2Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Add, BE4Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Add, BE6Vector)
 
 // +=
-static void addeq_BigVec(benchmark::State& state) {
-	state.PauseTiming();
-	BigVector a = makeVector<Poly>(parmArray[state.range(0)]);
-	BigVector b = makeVector<Poly>(parmArray[state.range(0)]);
-	state.ResumeTiming();
-
+template <typename V>
+static void addeq_BigVec(V& a, const V& b) {
 	a += b;
 }
 
+template <typename V>
 static void BM_BigVec_Addeq(benchmark::State& state) { // benchmark
+	auto p = state.range(0);
+	size_t idx = ElemParamFactory::GetNearestIndex(p);
+	typename V::Integer q( ElemParamFactory::DefaultSet[idx].q);
+	V b = makeVector<V>(p, q);
 
 	while (state.KeepRunning()) {
-		addeq_BigVec(state);
+		V a = makeVector<V>(p, q);
+		addeq_BigVec<V>(a,b);
 	}
 }
 
-DO_PARM_BENCHMARK(BM_BigVec_Addeq)
+DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Addeq)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Addeq, BE2Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Addeq, BE4Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Addeq, BE6Vector)
 
 // mult
-static void mult_BigVec(benchmark::State& state) {	// function
-	state.PauseTiming();
-	BigVector a = makeVector<Poly>(parmArray[state.range(0)]);
-	BigVector b = makeVector<Poly>(parmArray[state.range(0)]);
-	state.ResumeTiming();
-
-	a = a*b;
+template <typename V>
+static void mult_BigVec(const V& a, const V& b) {	// function
+	V c = a*b;
 }
 
-static void BM_BigVec_Multiplication(benchmark::State& state) { // benchmark
+template <typename V>
+static void BM_BigVec_Mult(benchmark::State& state) { // benchmark
+	auto p = state.range(0);
+	size_t idx = ElemParamFactory::GetNearestIndex(p);
+	typename V::Integer q( ElemParamFactory::DefaultSet[idx].q);
+	V a = makeVector<V>(p, q);
+	V b = makeVector<V>(p, q);
 
 	while (state.KeepRunning()) {
-		mult_BigVec(state);
+		mult_BigVec<V>(a, b);
 	}
 }
 
-DO_PARM_BENCHMARK(BM_BigVec_Multiplication)
+DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Mult)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Mult, BE2Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Mult, BE4Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Mult, BE6Vector)
 
 // mult
-static void multeq_BigVec(benchmark::State& state) {	// function
-	state.PauseTiming();
-	BigVector a = makeVector<Poly>(parmArray[state.range(0)]);
-	BigVector b = makeVector<Poly>(parmArray[state.range(0)]);
-	state.ResumeTiming();
-
+template <typename V>
+static void multeq_BigVec(V& a, const V& b) {
 	a *= b;
 }
 
+template <typename V>
 static void BM_BigVec_Multeq(benchmark::State& state) { // benchmark
+	auto p = state.range(0);
+	size_t idx = ElemParamFactory::GetNearestIndex(p);
+	typename V::Integer q( ElemParamFactory::DefaultSet[idx].q);
+	V b = makeVector<V>(p, q);
 
 	while (state.KeepRunning()) {
-		multeq_BigVec(state);
+		V a = makeVector<V>(p, q);
+		multeq_BigVec<V>(a,b);
 	}
 }
 
-DO_PARM_BENCHMARK(BM_BigVec_Multeq)
+DO_NATIVEVECTOR_BENCHMARK(BM_BigVec_Multeq)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Multeq, BE2Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Multeq, BE4Vector)
+DO_VECTOR_BENCHMARK_TEMPLATE(BM_BigVec_Multeq, BE6Vector)
 
 //execute the benchmarks
 BENCHMARK_MAIN()

benchmark/src/vechelper.h

@@ -32,19 +32,19 @@
 #include "math/backend.h"
 using namespace lbcrypto;
 
-template<typename P>
-inline typename P::Vector makeVector(shared_ptr<typename P::Params> p) {
-	typename P::DugType dug;
-	dug.SetModulus(p->GetModulus());
+template<typename V>
+inline V makeVector(usint ringdim, const typename V::Integer& mod) {
+	DiscreteUniformGeneratorImpl<typename V::Integer,V> dug;
+	dug.SetModulus(mod);
 
-	return dug.GenerateVector(p->GetCyclotomicOrder()/2);
+	return dug.GenerateVector(ringdim);
 }
 
-inline NativeVector makeNativeVector(shared_ptr<ILNativeParams> p) {
-	NativePoly::DugType dug;
-	dug.SetModulus(p->GetModulus());
+inline NativeVector makeNativeVector(usint ringdim, const NativeInteger& mod) {
+	DiscreteUniformGeneratorImpl<NativeInteger,NativeVector> dug;
+	dug.SetModulus(mod);
 
-	return dug.GenerateVector(p->GetRingDimension());
+	return dug.GenerateVector(ringdim);
 }
 
 #endif

src/core/lib/math/interface.h

@@ -379,7 +379,9 @@ namespace lbcrypto {
 
 	template<typename T, typename I>
 	class BigVectorInterface{
-public:
+	public:
+		typedef I Integer;
+
 		// CONSTRUCTORS
 
 		// Constructors should be implemented in the derived classes

src/pke/demo/Temp-smalldemo.cpp

+/*
+ * Temp-smalldemo.cpp
+ *
+ *  Created on: Jan 4, 2018
+ *      Author: gerardryan
+ */
+
+#include "palisade.h"
+
+int
+main()
+{
+	NativeInteger a(100);
+	NativeInteger b(100);
+
+	cout << sizeof(a) << endl;
+
+	NativeInteger c = a.Plus(b);
+
+//	uint64_t x;
+	//unsigned __int128 y;
+
+	a += b;
+
+	cout << a << " " << b << " " << c;
+	return 0;
+}
+
+