project update

Modules/ComputationalModules/Binary/AdditionModule.cs

@@ -0,0 +1,63 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class AdditionModule : BinaryComputationalModule, IPolymorphismModule
+{
+	private IDataPortGroup? InputGroup { get; set; }
+	private IDataPortGroup? OutputGroup { get; set; }
+	private DataOutPort? Output1 { get; set; }
+	private DataOutPort? Output2 { get; set; }
+	private DataOutPort? Output3 { get; set; }
+	private DataOutPort? Output4 { get; set; }
+	public override IEnumerable<BasePort> Ports =>
+		base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
+	public override double MaintenanceAlpha => 0.19572021d;
+	public override double MaintenanceBeta => 0.20151779d;
+	public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Output2 = GetPort<DataOutPort>("Output2");
+		Output3 = GetPort<DataOutPort>("Output3");
+		Output4 = GetPort<DataOutPort>("Output4");
+		
+		InputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
+			this,
+			new IDataPort[] { Input1, Input2 },
+			"",
+			EnigmosConstant.DataPortTypes.Real,
+			Array.Empty<StringName>()
+		);
+		OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+			this,
+			new IDataPort[] { Output1, Output2, Output3, Output4 },
+			"Output Port Type",
+			EnigmosConstant.DataPortTypes.Real,
+			EnigmosConstant.DataPortTypes.AnyTensor
+		);
+		ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
+		PostInit();
+	}
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		IDataPackage res = GlobalProvider.PolymorphismProvider!.Add(input1, input2, OutputGroup!.SelectedType);
+		foreach (IDataPort port in OutputGroup)
+			(port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+		
+	}
+
+	public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;
+
+	public override string GetDescription => GlobalProvider.EnigmosProvider.ModuleDescription<AdditionModule>();
+}

Modules/ComputationalModules/Binary/ComparisionModule.cs

@@ -0,0 +1,36 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.ConfigurableParameters;
+using Nocturnis.Enigmos.Modules;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class ComparisionModule : BinaryComputationalModule, IParameterizedModule
+{
+
+	private DataOutPort? Output { get; set; }
+	private IBoolParameter Greater { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output });
+	public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; }
+
+	public override void Init()
+	{
+		base.Init();
+		Greater = GlobalProvider.DataStructureProvider.NewBoolParameter("Method", "gt", "lt", true);
+		ConfigurableParameters = new HashSet<IConfigurableParameter>() { Greater };
+		Output = GetPort<DataOutPort>("Output");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Real);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Real);
+		Output.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		Output!.ResultData.Bit = !(Greater.ParameterValue ^ (input1.Real > input2.Real));
+	}
+}

Modules/ComputationalModules/Binary/ControlledOutputModule.cs

@@ -0,0 +1,56 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class ControlledOutputModule : BinaryComputationalModule, IPolymorphismModule
+{
+    [Export] private StringName PresetDataType { get; set; }
+    private DataOutPort Output1 { get; set; }
+    private DataOutPort Output2 { get; set; }
+    private DataOutPort Output3 { get; set; }
+    private DataOutPort Output4 { get; set; }
+    private IDataPortGroup OutputGroup { get; set; }
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 });
+    public void Inference() => Input2.SetDataType(OutputGroup.SelectedType);
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "Output Data Type",
+            UsingPreset ? PresetDataType : EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.AnyType
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
+        Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        Input2.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        PostInit();
+    }
+
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        if (input1.Bit)
+            foreach (DataOutPort port in OutputGroup.OfType<DataOutPort>())
+                port.ResultData.Assign(input2, OutputGroup.SelectedType);
+        else
+            foreach (DataOutPort port in OutputGroup.OfType<DataOutPort>())
+                port.ResultData.Assign(
+                    GlobalProvider.DataStructureProvider.DefaultDataPackage,
+                    OutputGroup.SelectedType
+                );
+    }
+}

Modules/ComputationalModules/Binary/DivisionModule.cs

@@ -0,0 +1,61 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class DivisionModule : BinaryComputationalModule, IPolymorphismModule
+{
+    private IDataPortGroup? InputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+    private DataOutPort? Output1 { get; set; }
+    private DataOutPort? Output2 { get; set; }
+    private DataOutPort? Output3 { get; set; }
+    private DataOutPort? Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input1, Input2 },
+            "",
+            EnigmosConstant.DataPortTypes.Real,
+            Array.Empty<StringName>()
+        );
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "Output Port Type",
+            EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.NumericTypes
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
+        PostInit();
+    }
+
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        IDataPackage res = GlobalProvider.PolymorphismProvider.Div(input1, input2, OutputGroup.SelectedType);
+        foreach (DataPort port in OutputGroup)
+        {
+            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+            //(port as DataOutPort)!.DataUpdated = true;
+        }
+    }
+
+    public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType;
+    
+}

Modules/ComputationalModules/Binary/DotProductModule.cs

@@ -0,0 +1,65 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class DotProductModule : BinaryComputationalModule, IPolymorphismModule
+{
+    private IDataPortGroup? VectorInputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+    private DataOutPort? Output1 { get; set; }
+    private DataOutPort? Output2 { get; set; }
+    private DataOutPort? Output3 { get; set; }
+    private DataOutPort? Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        VectorInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input1, Input2 },
+            "Vector Input Type",
+            EnigmosConstant.DataPortTypes.R2,
+            EnigmosConstant.DataPortTypes.VectorTypes
+        );
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "",
+            EnigmosConstant.DataPortTypes.Real,
+            Array.Empty<StringName>()
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { VectorInputGroup };
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        IDataPackage res = GlobalProvider.PolymorphismProvider!.Dot(input1, input2, VectorInputGroup!.SelectedType);
+        foreach (IDataPort port in OutputGroup!)
+            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+        
+    }
+    
+
+    public void Inference()
+    {
+        if (GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(VectorInputGroup!.SelectedType))
+            OutputGroup!.SelectedType = EnigmosConstant.DataPortTypes.Complex;
+        else
+            OutputGroup!.SelectedType = EnigmosConstant.DataPortTypes.Real;
+    }
+
+}

Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs

@@ -0,0 +1,28 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalAlternativeDenialModule : BinaryComputationalModule
+{
+	private DataOutPort Output1 { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		//Output1.DataUpdated = true;
+		Output1.ResultData.Bit = !input1.Bit | !input2.Bit;
+	}
+}

Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs

@@ -0,0 +1,28 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalBiconditionalModule : BinaryComputationalModule
+{
+	private DataOutPort Output1 { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		//Output1.DataUpdated = true;
+		Output1.ResultData.Bit = !(input1.Bit ^ input2.Bit);
+	}
+}

Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs

@@ -0,0 +1,27 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalConjunctionModule : BinaryComputationalModule
+{
+	private DataOutPort Output1 { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		//Output1.DataUpdated = true;
+		Output1.ResultData.Bit = input1.Bit & input2.Bit;
+	}
+}

Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs

@@ -0,0 +1,27 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalDisjunctionModule : BinaryComputationalModule
+{
+	private DataOutPort Output1 { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		//Output1.DataUpdated = true;
+		Output1.ResultData.Bit = input1.Bit | input2.Bit;
+	}
+}

Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs

@@ -0,0 +1,27 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalExclusiveDisjunctionModule : BinaryComputationalModule
+{
+	private DataOutPort Output1 { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+	
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		//Output1.DataUpdated = true;
+		Output1.ResultData.Bit = input1.Bit ^ input2.Bit;
+	}
+}

Modules/ComputationalModules/Binary/LogicalImplicationModule.cs

@@ -0,0 +1,27 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalImplicationModule : BinaryComputationalModule
+{
+	private DataOutPort? Output1 { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		//Output1.DataUpdated = true;
+		Output1.ResultData.Bit = !input1.Bit | input2.Bit;
+	}
+}

Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs

@@ -0,0 +1,28 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalJointDenialModule : BinaryComputationalModule
+{
+	private DataOutPort Output1 { get; set; }
+	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+	public override void Init()
+	{
+		base.Init();
+		Output1 = GetPort<DataOutPort>("Output1");
+		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+		PostInit();
+	}
+	
+
+	protected override void Compute(IDataPackage input1, IDataPackage input2)
+	{
+		//Output1.DataUpdated = true;
+		Output1.ResultData.Bit = !input1.Bit & !input2.Bit;
+	}
+}

Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs

@@ -0,0 +1,28 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class LogicalNonimplicationModule : BinaryComputationalModule
+{
+    private DataOutPort Output1 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        PostInit();
+    }
+
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        //Output1.DataUpdated = true;
+        Output1.ResultData.Bit = input1.Bit & !input2.Bit;
+    }
+}

Modules/ComputationalModules/Binary/MaxModule.cs

@@ -0,0 +1,44 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class MaxModule : BinaryComputationalModule
+{
+    private DataOutPort Output1 { get; set; }
+    private DataOutPort Output2 { get; set; }
+    private DataOutPort Output3 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3 });
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Input1.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Input2.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Output1.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Output2.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Output3.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        if (input1.Real > input2.Real)
+        {
+            Output1.ResultData.Real = input1.Real;
+            Output2.ResultData.Real = input1.Real;
+            Output3.ResultData.Real = input1.Real;
+        }
+        else
+        {
+            Output1.ResultData.Real = input2.Real;
+            Output2.ResultData.Real = input2.Real;
+            Output3.ResultData.Real = input2.Real;
+        }
+        
+    }
+}

Modules/ComputationalModules/Binary/MinModule.cs

@@ -0,0 +1,44 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Nocturnis.DataStructures;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class MinModule : BinaryComputationalModule
+{
+    private DataOutPort Output1 { get; set; }
+    private DataOutPort Output2 { get; set; }
+    private DataOutPort Output3 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3 });
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Input1.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Input2.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Output1.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Output2.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        Output3.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        if (input1.Real < input2.Real)
+        {
+            Output1.ResultData.Real = input1.Real;
+            Output2.ResultData.Real = input1.Real;
+            Output3.ResultData.Real = input1.Real;
+        }
+        else
+        {
+            Output1.ResultData.Real = input2.Real;
+            Output2.ResultData.Real = input2.Real;
+            Output3.ResultData.Real = input2.Real;
+        }
+
+    }
+}

Modules/ComputationalModules/Binary/MultiplicationModule.cs

@@ -0,0 +1,56 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class MultiplicationModule : BinaryComputationalModule, IPolymorphismModule
+{
+    private IDataPortGroup InputGroup { get; set; }
+    private IDataPortGroup OutputGroup { get; set; }
+    private DataOutPort Output1 { get; set; }
+    private DataOutPort Output2 { get; set; }
+    private DataOutPort Output3 { get; set; }
+    private DataOutPort Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 });
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; }
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new DataPort[] { Input1, Input2 },
+            "",
+            EnigmosConstant.DataPortTypes.Real,
+            Array.Empty<StringName>()
+        );
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new DataPort[] { Output1, Output2, Output3, Output4 },
+            "Output Port Type",
+            EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.NumericTypes
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        IDataPackage res = GlobalProvider.PolymorphismProvider.Mul(input1, input2, OutputGroup.SelectedType);
+        foreach (DataPort port in OutputGroup)
+            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+    }
+
+    public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType;
+
+}

Modules/ComputationalModules/Binary/PowerModule.cs

@@ -0,0 +1,63 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class PowerModule : BinaryComputationalModule, IPolymorphismModule
+{
+    private IDataPortGroup? TensorInputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+    private DataOutPort? Output1 { get; set; }
+    private DataOutPort? Output2 { get; set; }
+    private DataOutPort? Output3 { get; set; }
+    private DataOutPort? Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        TensorInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input1 },
+            "Base Tensor Type",
+            EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.NumericTypes
+        );
+        Input2.SetDataType(EnigmosConstant.DataPortTypes.Complex);
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "",
+            EnigmosConstant.DataPortTypes.Real,
+            Array.Empty<StringName>()
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { TensorInputGroup };
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        
+        IDataPackage res = GlobalProvider.PolymorphismProvider!.Pow(input1, input2, TensorInputGroup!.SelectedType);
+        foreach (IDataPort port in OutputGroup!)
+        {
+            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+            //(port as DataOutPort)!.DataUpdated = true;
+        }
+    }
+
+    public void Inference() => 
+        OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.ComplexVersionOf(TensorInputGroup.SelectedType);
+
+}

Modules/ComputationalModules/Binary/ScalarDivisionModule.cs

@@ -0,0 +1,123 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class ScalarDivisionModule : BinaryComputationalModule, IPolymorphismModule, IErrorHandlerModule
+{
+    private IDataPortGroup? ScalarInputGroup { get; set; }
+    private IDataPortGroup? TensorInputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+    private DataOutPort? Output1 { get; set; }
+    private DataOutPort? Output2 { get; set; }
+    private DataOutPort? Output3 { get; set; }
+    private DataOutPort? Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
+    public override double MaintenanceAlpha => 0.77852142d;
+    public override double MaintenanceBeta => 0.9544432d;
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        TensorInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input1 },
+            "Tensor Input Type",
+            EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.VectorTypes
+        );
+        ScalarInputGroup =GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input2 },
+            "Scalar Input Type",
+            EnigmosConstant.DataPortTypes.R2,
+            EnigmosConstant.DataPortTypes.VectorTypes
+        );
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "",
+            EnigmosConstant.DataPortTypes.Real,
+            Array.Empty<StringName>()
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { ScalarInputGroup, TensorInputGroup };
+        SelectedOption = 0;
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        try
+        {
+            IDataPackage res =
+                GlobalProvider.PolymorphismProvider!.ScalarDiv(
+                    input1,
+                    input2,
+                    TensorInputGroup!.SelectedType,
+                    ScalarInputGroup!.SelectedType
+                );
+            foreach (IDataPort port in OutputGroup)
+                (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+               
+        }
+        catch (Exception e)
+        {
+            ErrorHandler(e, SelectedOption);
+        }
+
+        
+    }
+
+    public void Inference()
+    {
+        if (GlobalProvider.DataPackageTypeProvider.IsComplexTensorType(ScalarInputGroup.SelectedType))
+            OutputGroup.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup.SelectedType);
+        else
+            OutputGroup.SelectedType = TensorInputGroup.SelectedType;
+    }
+
+    public void ErrorHandler(Exception error, int idx)
+    {
+        switch (idx)
+        {
+            case 0:
+                foreach (IDataPort port in OutputGroup!)
+                    (port as DataOutPort)!.ResultData
+                        .Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, OutputGroup.SelectedType);
+                break;
+            case 1:
+                foreach (IDataPort port in OutputGroup!)
+                    (port as DataOutPort)!.ResultData
+                        .Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, OutputGroup.SelectedType);
+                break;
+            case 2:
+                foreach (IDataPort port in OutputGroup!)
+                    (port as DataOutPort)!.ResultData
+                        .Assign(GlobalProvider.DataStructureProvider!.DefaultDataPackage, OutputGroup.SelectedType);
+                break;
+            default:
+                return;
+        }
+    }
+
+    public string[] HandlingOptions() =>
+        new[]
+        {
+            "Reset Circuit State",
+            "Return Previous Valid Value",
+            "Return Default Value"
+        };
+
+    public int SelectedOption { get; set; }
+}

Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs

@@ -0,0 +1,77 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class ScalarMultiplicationModule : BinaryComputationalModule, IPolymorphismModule
+{
+    private IDataPortGroup? ScalarInputGroup { get; set; }
+    private IDataPortGroup? TensorInputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+    private DataOutPort? Output1 { get; set; }
+    private DataOutPort? Output2 { get; set; }
+    private DataOutPort? Output3 { get; set; }
+    private DataOutPort? Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        ScalarInputGroup =  GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input1 },
+            "Scalar Input Type",
+            EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.NumericTypes
+        );
+        TensorInputGroup =  GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input2 },
+            "Tensor Input Type",
+            EnigmosConstant.DataPortTypes.R2,
+            EnigmosConstant.DataPortTypes.VectorTypes
+        );
+        OutputGroup =  GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "",
+            EnigmosConstant.DataPortTypes.Real,
+            Array.Empty<StringName>()
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { ScalarInputGroup, TensorInputGroup };
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        IDataPackage res = 
+            GlobalProvider.PolymorphismProvider!
+                .ScalarMul(input1, input2, ScalarInputGroup!.SelectedType, TensorInputGroup!.SelectedType);
+        foreach (IDataPort port in OutputGroup!)
+            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+            
+    }
+
+    public void Inference()
+    {
+        if (
+            GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(ScalarInputGroup!.SelectedType) ||
+            GlobalProvider.DataPackageTypeProvider.IsComplexTensorType(TensorInputGroup!.SelectedType)
+        )
+            OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup!.SelectedType);
+        else
+            OutputGroup!.SelectedType = TensorInputGroup.SelectedType;
+    }
+
+}

Modules/ComputationalModules/Binary/SubtractionModule.cs

@@ -0,0 +1,58 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class SubtractionModule : BinaryComputationalModule, IPolymorphismModule
+{
+    private IDataPortGroup InputGroup { get; set; }
+    private IDataPortGroup OutputGroup { get; set; }
+    private DataOutPort Output1 { get; set; }
+    private DataOutPort Output2 { get; set; }
+    private DataOutPort Output3 { get; set; }
+    private DataOutPort Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 });
+    
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; }
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input1, Input2 },
+            "",
+            EnigmosConstant.DataPortTypes.Real,
+            Array.Empty<StringName>()
+        );
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "Output Port Type",
+            EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.AnyTensor
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        IDataPackage res = GlobalProvider.PolymorphismProvider.Sub(input1, input2, OutputGroup.SelectedType);
+        foreach (DataPort port in OutputGroup)
+            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+    }
+
+    public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType;
+
+}

Modules/ComputationalModules/Binary/V2Module.cs

@@ -0,0 +1,70 @@
+using Enigmos.Ports;
+using Enigmos.Ports.DataPorts;
+using Godot;
+using Nocturnis.DataStructures;
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Ports;
+using TabulaSmaragdina;
+using TabulaSmaragdina.Constants;
+using R2 = Skeleton.Algebra.CategoryOf<Skeleton.Algebra.DimensionProviders.IDim2>.OnField<double>.FVector;
+using C2 = Skeleton.Algebra.CategoryOf<Skeleton.Algebra.DimensionProviders.IDim2>.OnField<System.Numerics.Complex>.FVector;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public partial class V2Module : BinaryComputationalModule, IPolymorphismModule
+{
+    private IDataPortGroup? ScalarInputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+    private DataOutPort? Output1 { get; set; }
+    private DataOutPort? Output2 { get; set; }
+    private DataOutPort? Output3 { get; set; }
+    private DataOutPort? Output4 { get; set; }
+    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
+    public override double MaintenanceAlpha => 0.77852142d;
+    public override double MaintenanceBeta => 0.9544432d;
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+
+    public override void Init()
+    {
+        base.Init();
+        Output1 = GetPort<DataOutPort>("Output1");
+        Output2 = GetPort<DataOutPort>("Output2");
+        Output3 = GetPort<DataOutPort>("Output3");
+        Output4 = GetPort<DataOutPort>("Output4");
+        ScalarInputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
+            this,
+            new IDataPort[] { Input1, Input2 },
+            "Scalar Input Type",
+            EnigmosConstant.DataPortTypes.Real,
+            EnigmosConstant.DataPortTypes.NumericTypes
+        );
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+            this,
+            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            "",
+            EnigmosConstant.DataPortTypes.R2,
+            Array.Empty<StringName>()
+        );
+        ConfigurablePortGroups = new HashSet<IDataPortGroup> { ScalarInputGroup };
+        PostInit();
+    }
+
+    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    {
+        R2 v2R = new R2(input1.Real, input2.Real);
+        C2 v2C = new C2(input1.Complex, input2.Complex);
+        foreach (IDataPort port in OutputGroup!)
+        {
+            if (ScalarInputGroup!.SelectedType == EnigmosConstant.DataPortTypes.Real)
+                (port as DataOutPort)!.ResultData.R2 = v2R;
+            else 
+                (port as DataOutPort)!.ResultData.C2 = v2C;
+        }
+    }
+
+    public void Inference()
+    {
+        OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.BuildType(OutputGroup.SelectedType, 1, 2);
+    }
+
+}