Function registry fix.

src/core/ICodedFunction.cs

@@ -10,6 +10,7 @@ namespace csmic
     {
         #region Properties
 
+        string Name { get; }
         IEnumerable<FunctionArgument> ExpectedArguments { get; }
         FunctionValue ReturnValue { get; }
 

src/core/InputInterpreter.cs

@@ -173,9 +173,9 @@ namespace csmic
 
         #region Functions
 
-        internal void RegisterFunction(string name, ICodedFunction function)
+        public void RegisterFunction(ICodedFunction function)
         {
-            functions[name] = function;
+            functions[function.Name] = function;
         }
 
         internal FunctionValue ExecuteFunction(string name, params FunctionArgument[] args)

src/stdlib/Constants.cs

@@ -1,8 +1,8 @@
 namespace csmic.stdlib
 {
-    public class Constants
+    public static class Constants
     {
-        public void Initialize(InputInterpreter inputInterpreter)
+        public static void Initialize(InputInterpreter inputInterpreter)
         {
             if(inputInterpreter == null)
             {

src/stdlib/Functions.cs

@@ -0,0 +1,26 @@
+using csmic;
+using stdlib.functions;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace stdlib
+{
+    public static class Functions
+    {
+        public static void Initialize(InputInterpreter inputInterpreter)
+        {
+            if (inputInterpreter == null)
+            {
+                throw new ArgumentNullException("inputInterpreter", "Cannot initialize a null InputInterpreter.");
+            }
+
+            inputInterpreter.RegisterFunction(new AbsoluteValue());
+            inputInterpreter.RegisterFunction(new Sign());
+            inputInterpreter.RegisterFunction(new Min());
+            inputInterpreter.RegisterFunction(new Max());
+        }
+    }
+}

src/stdlib/functions/AbsoluteValue.cs

@@ -5,6 +5,14 @@ namespace stdlib.functions
 {
     public class AbsoluteValue : FunctionBase, ICodedFunction
     {
+        public string Name
+        {
+            get
+            {
+                return "abs";
+            }
+        }
+
         public override IEnumerable<FunctionArgument> ExpectedArguments
         {
             get

src/stdlib/functions/Max.cs

@@ -9,6 +9,14 @@ namespace stdlib.functions
 {
     public class Max : FunctionBase, ICodedFunction
     {
+        public string Name
+        {
+            get
+            {
+                return "max";
+            }
+        }
+
         public override IEnumerable<FunctionArgument> ExpectedArguments
         {
             get

src/stdlib/functions/Min.cs

@@ -9,6 +9,14 @@ namespace stdlib.functions
 {
     public class Min : FunctionBase, ICodedFunction
     {
+        public string Name
+        {
+            get
+            {
+                return "min";
+            }
+        }
+
         public override IEnumerable<FunctionArgument> ExpectedArguments
         {
             get

src/stdlib/functions/Sign.cs

@@ -8,6 +8,14 @@ namespace stdlib.functions
         public const decimal POSITIVE = 1;
         public const decimal NEGATIVE = -1;
 
+        public string Name
+        {
+            get
+            {
+                return "sign";
+            }
+        }
+
         public override IEnumerable<FunctionArgument> ExpectedArguments
         {
             get

src/tests/StdlibFunctionsTests.cs

@@ -1,105 +1,24 @@
 using csmic;
+using csmic.stdlib;
 using NUnit.Framework;
+using stdlib;
 using stdlib.functions;
+using System.Globalization;
+using System.Reflection.Metadata;
 
 namespace tests;
 
 public class StdlibFunctionsTests
 {
-    private static FunctionArgument NumArg(decimal d) => new FunctionArgument("value", new FunctionValue(FunctionValueType.Numeric, d));
+    private InputInterpreter _interp = null!;
 
-    [Test]
+    [SetUp]
-    public void AbsoluteValue_Positive_ReturnsSame()
+    public void Setup()
     {
-        var fn = new AbsoluteValue();
+        CultureInfo.CurrentCulture = CultureInfo.InvariantCulture;
-        var result = fn.Execute(NumArg(5m));
+        _interp = new InputInterpreter();
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.Numeric));
+        Constants.Initialize(_interp);
-        Assert.That(result.Value, Is.EqualTo(5m));
+        Functions.Initialize(_interp); ;
-    }
-
-    [Test]
-    public void AbsoluteValue_Negative_ReturnsPositive()
-    {
-        var fn = new AbsoluteValue();
-        var result = fn.Execute(NumArg(-12.5m));
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.Numeric));
-        Assert.That(result.Value, Is.EqualTo(12.5m));
-    }
-
-    [Test]
-    public void AbsoluteValue_Zero_ReturnsZero()
-    {
-        var fn = new AbsoluteValue();
-        var result = fn.Execute(NumArg(0m));
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.Numeric));
-        Assert.That(result.Value, Is.EqualTo(0m));
-    }
-
-    [Test]
-    public void AbsoluteValue_InvalidArgType_ReturnsNone()
-    {
-        var fn = new AbsoluteValue();
-        var badArg = new FunctionArgument("value", FunctionValue.STRING);
-        var result = fn.Execute(badArg);
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.None));
-        Assert.That(result.Value, Is.Null);
-    }
-
-    [Test]
-    public void AbsoluteValue_WrongArgCount_ReturnsNone()
-    {
-        var fn = new AbsoluteValue();
-        var result0 = fn.Execute();
-        var result2 = fn.Execute(NumArg(1m), NumArg(2m));
-        Assert.That(result0.Type, Is.EqualTo(FunctionValueType.None));
-        Assert.That(result2.Type, Is.EqualTo(FunctionValueType.None));
-    }
-
-    [Test]
-    public void Sign_Negative_ReturnsNegativeOne()
-    {
-        var fn = new Sign();
-        var result = fn.Execute(NumArg(-1m));
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.Numeric));
-        Assert.That(result.Value, Is.EqualTo(Sign.NEGATIVE));
-    }
-
-    [Test]
-    public void Sign_Zero_ReturnsPositiveOne()
-    {
-        var fn = new Sign();
-        var result = fn.Execute(NumArg(0m));
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.Numeric));
-        Assert.That(result.Value, Is.EqualTo(Sign.POSITIVE));
-    }
-
-    [Test]
-    public void Sign_Positive_ReturnsPositiveOne()
-    {
-        var fn = new Sign();
-        var result = fn.Execute(NumArg(99.99m));
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.Numeric));
-        Assert.That(result.Value, Is.EqualTo(Sign.POSITIVE));
-    }
-
-    [Test]
-    public void Sign_InvalidArgType_ReturnsNone()
-    {
-        var fn = new Sign();
-        var badArg = new FunctionArgument("value", FunctionValue.STRING);
-        var result = fn.Execute(badArg);
-        Assert.That(result.Type, Is.EqualTo(FunctionValueType.None));
-        Assert.That(result.Value, Is.Null);
-    }
-
-    [Test]
-    public void Sign_WrongArgCount_ReturnsNone()
-    {
-        var fn = new Sign();
-        var result0 = fn.Execute();
-        var result2 = fn.Execute(NumArg(1m), NumArg(2m));
-        Assert.That(result0.Type, Is.EqualTo(FunctionValueType.None));
-        Assert.That(result2.Type, Is.EqualTo(FunctionValueType.None));
     }
 }