changed to gtest

.gitmodules

@@ -0,0 +1,3 @@
+[submodule "lib/gtest"]
+	path = lib/gtest
+	url = https://github.com/google/googletest.git

CMakeLists.txt

@@ -80,6 +80,8 @@ IF(BUILD_SHARED_LIBS)
 ENDIF(BUILD_SHARED_LIBS)
 
 IF(ENABLE_TESTS)
+	add_subdirectory(lib/gtest)
+
 	add_subdirectory (tests)
 
 	enable_testing()
@@ -87,6 +89,9 @@ enable_testing()
 	add_test(activation tests/backpropagation)
 	set_property(TEST activation PROPERTY LABELS unit)
 
+
+#[[
+
 	add_test(backpropagation tests/backpropagation)
 	set_property(TEST backpropagation PROPERTY LABELS unit)
 
@@ -126,4 +131,5 @@ set_property(TEST backpropagation_perf PROPERTY LABELS perf)
 	add_test(recurrent_perf tests/recurrent_perf)
 	set_property(TEST recurrent_perf PROPERTY LABELS perf)
 
+]]
 ENDIF(ENABLE_TESTS)

tests/CMakeLists.txt

@@ -1,11 +1,18 @@
 cmake_minimum_required(VERSION 3.2)
+
 project(NeuralNetworkTests CXX)
 
+set(CMAKE_CXX_FLAGS " --std=c++14")
+
 add_executable(activation activation.cpp)
 target_link_libraries(activation NeuralNetwork)
+target_link_libraries(activation gtest gtest_main)
 
 add_executable(basis basis.cpp)
 target_link_libraries(basis NeuralNetwork)
+target_link_libraries(basis gtest gtest_main)
+
+#[[
 
 add_executable(backpropagation backpropagation.cpp)
 target_link_libraries(backpropagation NeuralNetwork)
@@ -44,4 +51,4 @@ add_executable(quickpropagation_perf quickpropagation_perf.cpp)
 target_link_libraries(quickpropagation_perf NeuralNetwork)
 
 add_executable(propagation_cmp propagation_cmp.cpp)
-target_link_libraries(propagation_cmp NeuralNetwork)
+target_link_libraries(propagation_cmp NeuralNetwork)]]

tests/activation.cpp

@@ -3,70 +3,69 @@
 #include <NeuralNetwork/ActivationFunction/HyperbolicTangent.h>
 #include <NeuralNetwork/ActivationFunction/Linear.h>
 
-#include <iostream>
+#include "gtest/gtest.h"
-#include <cassert>
-#include <chrono>
 
-union {
+union SSE {
-    __m128 v;    // SSE 4 x float vector
+    __m128 sse;    // SSE 4 x float vector
-    float a[4];  // scalar array of 4 floats
+    float floats[4];  // scalar array of 4 floats
-} U;
+};
 
-int main() {
+TEST(Heaviside, ParamOne) {
-	{
 	NeuralNetwork::ActivationFunction::Heaviside h(1.0);
-		assert(h(0.2) == 0);
+	ASSERT_EQ(h(0.2), 0);
-		assert(h(1.2) == 1);
+	ASSERT_EQ(h(1.2), 1);
 }
 
-	{
+TEST(Heaviside, ParamZeroPointSeven) {
 	NeuralNetwork::ActivationFunction::Heaviside h(0.7);
-		assert(h(0.2) == 0);
+	ASSERT_EQ(h(0.2), 0);
-		assert(h(0.8) == 1);
+	ASSERT_EQ(h(0.8), 1);
 }
 
-	{
+TEST(Sigmoid, ParamZeroPointSeven) {
 	NeuralNetwork::ActivationFunction::Sigmoid s(0.7);
-		assert(s(0.1) > 0.482407);
+	ASSERT_GT(s(0.1), 0.482407);
-		assert(s(0.1) < 0.482607);
+	ASSERT_LT(s(0.1), 0.482607);
 
-		assert(s(10) > 0.000901051);
+	ASSERT_GT(s(10), 0.000901051);
-		assert(s(10) < 0.000921051);
+	ASSERT_LT(s(10), 0.000921051);
 }
-	{
+
+TEST(Sigmoid, ParamMinusFive) {
 	NeuralNetwork::ActivationFunction::Sigmoid s(-5);
-		assert(s(0.1) > 0.622359);
+	ASSERT_GT(s(0.1), 0.622359);
-		assert(s(0.1) < 0.622559);
+	ASSERT_LT(s(0.1), 0.622559);
 
-		assert(s(0.7) > 0.970588);
+	ASSERT_GT(s(0.7), 0.970588);
-		assert(s(0.7) < 0.970788);
+	ASSERT_LT(s(0.7), 0.970788);
 }
-	{
+
+TEST(SigmoidSSE, ParamMinusZeroPointSeven) {
 	NeuralNetwork::ActivationFunction::Sigmoid s(-0.7);
-		U.a[0]=0.1;
+	SSE comp;
-		U.a[1]=10;
+	comp.floats[0]=0.1;
-		U.v=s(U.v);
+	comp.floats[1]=10;
+	comp.sse=s(comp.sse);
 
-		assert(U.a[0] > 0.517483);
+	ASSERT_GT(comp.floats[0], 0.517483);
-		assert(U.a[0] < 0.51750);
+	ASSERT_LT(comp.floats[0], 0.51750);
 
-		assert(U.a[1] > 0.998989);
+	ASSERT_GT(comp.floats[1], 0.998989);
-		assert(U.a[1] < 0.999189);
+	ASSERT_LT(comp.floats[1], 0.999189);
 }
-	{
+
+TEST(Linear, ParamOne) {
 	NeuralNetwork::ActivationFunction::Linear s(1.0);
-		assert(s(0.5) > 0.4999);
+	ASSERT_GT(s(0.5), 0.4999);
-		assert(s(0.5) < 0.5001);
+	ASSERT_LT(s(0.5), 0.5001);
 
-		assert(s(0.0) == 0.0);
+	ASSERT_EQ(s(0.0), 0.0);
 }
-	{
+
+TEST(Linear, ParamZeroPointSeven) {
 	NeuralNetwork::ActivationFunction::Linear s(0.7);
-		assert(s(0.0) == 0.0);
+	ASSERT_GT(s(1.0), 0.6999);
+	ASSERT_LT(s(1.0), 0.7001);
 
-		assert(s(1.0) > 0.6999);
+	ASSERT_EQ(s(0.0), 0.0);
-		assert(s(1.0) < 0.7001);
-	}
-
-	return 0;
 }

tests/basis.cpp

@@ -1,41 +1,41 @@
 #include <NeuralNetwork/BasisFunction/Linear.h>
 #include <NeuralNetwork/BasisFunction/Product.h>
 
-#include <iostream>
+#include "gtest/gtest.h"
-#include <cassert>
-#include <chrono>
 
-int main() {
+TEST(Linear,FourElements) {
-	{
 	NeuralNetwork::BasisFunction::Linear l;
-		assert(39.0==l({1,2,3,5},{1,2,3,5}));
+	ASSERT_EQ(39.0, l({1,2,3,5},{1,2,3,5}));
 }
-	{
+
+TEST(Linear,FiveElements) {
 	NeuralNetwork::BasisFunction::Linear l;
-		assert(88.0==l({1,2,3,5,7},{1,2,3,5,7}));
+	ASSERT_EQ(88.0, l({1,2,3,5,7},{1,2,3,5,7}));
 }
-	{
+
+TEST(Linear,HundredElements) {
 	NeuralNetwork::BasisFunction::Linear l;
 	std::vector<float> w;
 	for(int in=0;in<100;in++) {
 		w.push_back(2);
 	}
-		assert(400.0==l(w,w));
+	ASSERT_EQ(400.0, l(w,w));
 }
-	{
+
+TEST(Linear,FivetyFiveElements) {
 	NeuralNetwork::BasisFunction::Linear l;
 	std::vector<float> w;
 	for(int in=0;in<55;in++) {
 		w.push_back(2);
 	}
-		assert(220.0==l(w,w));
+	ASSERT_EQ(220.0, l(w,w));
 }
-	{
+
-		NeuralNetwork::BasisFunction::Product l;
+TEST(Product,Product) {
+	NeuralNetwork::BasisFunction::Product p;
 	std::vector<float> w({0,0.501,1});
 	std::vector<float> i({0,0.2,0.3});
 
-		assert(l(w,i) > 0.05999);
+	ASSERT_GT(p(w,i), 0.05999);
-		assert(l(w,i) < 0.06001);
+	ASSERT_LT(p(w,i), 0.06001);
-	}
 }