changed to gtest

tests/activation.cpp

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