[US-IF-005]: Implement missing activation functions in ActivationFunctionFactory (#162)

* refactor(US-IF-005): Complete ActivationFunctionFactory mappings for all enum values

- Map scalar factory to: ReLU, Sigmoid, Tanh, Linear(Identity), LeakyReLU, ELU, SELU, Softplus, SoftSign, Swish, GELU; Softmax guarded as vector-only
- Map vector factory to the same set plus Softmax

References: ~/.claude/user-stories/AiDotNet/code_improvements/us-if-005-implement-missing-activation-functions-in-activationfunctionfactory.md

* test(US-IF-005): Add ActivationFunctionFactory coverage tests

* test(US-IF-005): Add behavior tests for common activation functions (increase coverage)

* refactor(US-IF-005): Combine Linear/Identity into single or-pattern mapping per Copilot review

Author: ooples

src/Factories/ActivationFunctionFactory.cs

@@ -47,13 +47,13 @@ public static IActivationFunction<T> CreateActivationFunction(ActivationFunction
         return activationFunction switch
         {
             ActivationFunction.ReLU => new ReLUActivation<T>(),
-            ActivationFunction.Softmax => throw new NotSupportedException("Softmax is not applicable to single values. Use CreateVectorActivationFunction for Softmax."),
             ActivationFunction.Sigmoid => new SigmoidActivation<T>(),
             ActivationFunction.Tanh => new TanhActivation<T>(),
-            ActivationFunction.Identity => new IdentityActivation<T>(),
+            ActivationFunction.Linear or ActivationFunction.Identity => new IdentityActivation<T>(),
             ActivationFunction.LeakyReLU => new LeakyReLUActivation<T>(),
             ActivationFunction.ELU => new ELUActivation<T>(),
             ActivationFunction.SELU => new SELUActivation<T>(),
+            ActivationFunction.Softmax => throw new NotSupportedException("Softmax is not applicable to single values. Use CreateVectorActivationFunction for Softmax."),
             ActivationFunction.Softplus => new SoftPlusActivation<T>(),
             ActivationFunction.SoftSign => new SoftSignActivation<T>(),
             ActivationFunction.Swish => new SwishActivation<T>(),
@@ -87,9 +87,10 @@ public static IVectorActivationFunction<T> CreateVectorActivationFunction(Activa
         return activationFunction switch
         {
             ActivationFunction.Softmax => new SoftmaxActivation<T>(),
+            ActivationFunction.ReLU => new ReLUActivation<T>(),
             ActivationFunction.Sigmoid => new SigmoidActivation<T>(),
             ActivationFunction.Tanh => new TanhActivation<T>(),
-            ActivationFunction.Identity => new IdentityActivation<T>(),
+            ActivationFunction.Linear or ActivationFunction.Identity => new IdentityActivation<T>(),
             ActivationFunction.LeakyReLU => new LeakyReLUActivation<T>(),
             ActivationFunction.ELU => new ELUActivation<T>(),
             ActivationFunction.SELU => new SELUActivation<T>(),

tests/ActivationFunctions/ActivationFunctionBehaviorTests.cs

@@ -0,0 +1,86 @@
+using System;
+using AiDotNet.ActivationFunctions;
+using AiDotNet.Enums;
+using AiDotNet.Factories;
+using AiDotNet.Interfaces;
+using Xunit;
+
+namespace AiDotNet.Tests.ActivationFunctions
+{
+    public class ActivationFunctionBehaviorTests
+    {
+        private static void AssertClose(double actual, double expected, double tol = 1e-6)
+        {
+            Assert.True(Math.Abs(actual - expected) <= tol, $"Actual {actual} != Expected {expected}");
+        }
+
+        [Fact]
+        public void ReLU_Activate_And_Derivative()
+        {
+            var fn = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.ReLU);
+            AssertClose(fn.Activate(-1.0), 0.0);
+            AssertClose(fn.Activate(2.5), 2.5);
+            AssertClose(fn.Derivative(-1.0), 0.0);
+        }
+
+        [Fact]
+        public void Sigmoid_Activate_And_Derivative()
+        {
+            var fn = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.Sigmoid);
+            var y = fn.Activate(0.0);
+            AssertClose(y, 0.5);
+            var dy = fn.Derivative(0.0);
+            Assert.True(dy > 0.0 && dy < 0.3);
+        }
+
+        [Fact]
+        public void Tanh_Activate_And_Derivative()
+        {
+            var fn = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.Tanh);
+            AssertClose(fn.Activate(0.0), 0.0);
+        }
+
+        [Fact]
+        public void Identity_Activate()
+        {
+            var fn = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.Linear);
+            AssertClose(fn.Activate(3.14), 3.14);
+        }
+
+        [Fact]
+        public void LeakyRelu_Activate()
+        {
+            var fn = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.LeakyReLU);
+            Assert.True(fn.Activate(-2.0) < 0 && fn.Activate(2.0) > 0);
+        }
+
+        [Fact]
+        public void ELU_SELU_Activate()
+        {
+            var elu = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.ELU);
+            var selu = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.SELU);
+            Assert.True(elu.Activate(-1.0) < 0.0);
+            Assert.True(selu.Activate(-1.0) < 0.0);
+        }
+
+        [Fact]
+        public void Softplus_SoftSign_Swish_GELU()
+        {
+            var sp = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.Softplus);
+            var ss = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.SoftSign);
+            var sw = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.Swish);
+            var ge = ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.GELU);
+            Assert.True(sp.Activate(1.0) > 0.0);
+            Assert.True(ss.Activate(1.0) > 0.0 && ss.Activate(1.0) <= 1.0);
+            Assert.True(sw.Activate(1.0) > 0.0);
+            Assert.True(ge.Activate(1.0) > 0.0);
+        }
+
+        [Fact]
+        public void Vector_Softmax_Factory()
+        {
+            var vfn = ActivationFunctionFactory<double>.CreateVectorActivationFunction(ActivationFunction.Softmax);
+            Assert.IsAssignableFrom<IVectorActivationFunction<double>>(vfn);
+        }
+    }
+}

tests/Factories/ActivationFunctionFactoryTests.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Linq;
+using AiDotNet.Enums;
+using AiDotNet.Factories;
+using AiDotNet.Interfaces;
+using Xunit;
+
+namespace AiDotNet.Tests.Factories
+{
+    public class ActivationFunctionFactoryTests
+    {
+        [Fact]
+        public void CreateActivationFunction_Returns_For_Scalar_Compatible()
+        {
+            // Scalar-compatible functions in current enum
+            var scalarValues = new[]
+            {
+                ActivationFunction.ReLU,
+                ActivationFunction.Sigmoid,
+                ActivationFunction.Tanh,
+                ActivationFunction.Linear,
+                ActivationFunction.LeakyReLU,
+                ActivationFunction.ELU,
+                ActivationFunction.SELU,
+                ActivationFunction.Softplus,
+                ActivationFunction.SoftSign,
+                ActivationFunction.Swish,
+                ActivationFunction.GELU,
+                ActivationFunction.Identity
+            };
+
+            foreach (var af in scalarValues)
+            {
+                var fn = ActivationFunctionFactory<double>.CreateActivationFunction(af);
+                Assert.NotNull(fn);
+                Assert.IsAssignableFrom<IActivationFunction<double>>(fn);
+            }
+        }
+
+        [Fact]
+        public void CreateActivationFunction_Throws_For_Softmax_Scalar()
+        {
+            Assert.Throws<NotSupportedException>(() =>
+                ActivationFunctionFactory<double>.CreateActivationFunction(ActivationFunction.Softmax));
+        }
+
+        [Fact]
+        public void CreateVectorActivationFunction_Returns_For_Vector_Compatible()
+        {
+            // Vector-compatible functions in current enum (includes Softmax)
+            var vectorValues = new[]
+            {
+                ActivationFunction.Softmax,
+                ActivationFunction.ReLU,
+                ActivationFunction.Sigmoid,
+                ActivationFunction.Tanh,
+                ActivationFunction.Linear,
+                ActivationFunction.LeakyReLU,
+                ActivationFunction.ELU,
+                ActivationFunction.SELU,
+                ActivationFunction.Softplus,
+                ActivationFunction.SoftSign,
+                ActivationFunction.Swish,
+                ActivationFunction.GELU,
+                ActivationFunction.Identity
+            };
+
+            foreach (var af in vectorValues)
+            {
+                var fn = ActivationFunctionFactory<double>.CreateVectorActivationFunction(af);
+                Assert.NotNull(fn);
+                Assert.IsAssignableFrom<IVectorActivationFunction<double>>(fn);
+            }
+        }
+    }
+}
+