Upgrade structure of code base

Modules/ComputationalModules/Binary/AdditionModule.cs

@@ -1,24 +1,20 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class AdditionModule : BinaryComputationalModule, IPolymorphismModule
+public partial class AdditionModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
-	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 })!;
+	private IDataInGroup? InputGroup { get; set; }
+	private IDataOutGroup? OutputGroup { get; set; }
+
+	public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
 	public override double MaintenanceAlpha => 0.19572021d;
 	public override double MaintenanceBeta => 0.20151779d;
 	public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
@@ -26,21 +22,18 @@ public partial class AdditionModule : BinaryComputationalModule, IPolymorphismMo
 	public override void Init()
 	{
 		base.Init();
-		Output1 = GetPort<DataOutPort>("Output1");
-		Output2 = GetPort<DataOutPort>("Output2");
-		Output3 = GetPort<DataOutPort>("Output3");
-		Output4 = GetPort<DataOutPort>("Output4");
+		this.DataOutInit("Output",4);
 		
-		InputGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
+		InputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
 			this,
-			new IDataPort[] { Input1, Input2 },
+			DataInPorts,
 			"",
 			EnigmosConstant.DataPortTypes.Real,
 			Array.Empty<StringName>()
 		);
-		OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+		OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
 			this,
-			new IDataPort[] { Output1, Output2, Output3, Output4 },
+			DataOutPorts,
 			"Output Port Type",
 			EnigmosConstant.DataPortTypes.Real,
 			EnigmosConstant.DataPortTypes.AnyTensor
@@ -49,15 +42,13 @@ public partial class AdditionModule : BinaryComputationalModule, IPolymorphismMo
 		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>();
+	public override string GetDescription => GlobalProvider.EnigmosProvider!.ModuleDescription<AdditionModule>();
+	public override void Define()
+	{
+		(object, StringName) Proxy(CacheItem cache) => 
+			GlobalProvider.PolymorphismProvider!.Add(this.X(cache), this.Y(cache));
+		this.Define(Proxy);
+	}
 }

Modules/ComputationalModules/Binary/BinaryLogicModule.cs

@@ -0,0 +1,17 @@
+using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+
+namespace Enigmos.Modules.ComputationalModules.Binary;
+
+public abstract partial class BinaryLogicModule:BinaryComputationalModule,ILogicModule, IDuplicateOutputModule
+{
+    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
+    public override void Init()
+    {
+        base.Init();
+        this.DataOutInit("Output", 1);
+        this.LogicModuleInit();
+        PostInit();
+    }
+}

Modules/ComputationalModules/Binary/ComparisionModule.cs

@@ -1,36 +1,41 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
 using Nocturnis.DataStructures.ConfigurableParameters;
 using Nocturnis.Enigmos.Modules;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ComparisionModule : BinaryComputationalModule, IParameterizedModule
+public partial class ComparisionModule : BinaryComputationalModule,
+	IParameterizedModule, 
+	IDuplicateOutputModule,
+	IOperationModule
 {
-
-	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; }
+	private IBoolParameter? Greater { get; set; }
+	public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
+	public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
 
 	public override void Init()
 	{
 		base.Init();
-		Greater = GlobalProvider.DataStructureProvider.NewBoolParameter("Method", "gt", "lt", true);
+		this.DataOutInit("Output",1);
+		this.SetInputType(EnigmosConstant.DataPortTypes.Real);
+		this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
+		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)
+	public override void Define()
 	{
-		Output!.ResultData.Bit = !(Greater.ParameterValue ^ (input1.Real > input2.Real));
+		this.Define(
+			cache => (
+				!(Greater!.ParameterValue ^ (this.X(cache).Double > this.Y(cache).Double)),
+				EnigmosConstant.DataPortTypes.Bit
+			)
+		);
 	}
+	
 }

Modules/ComputationalModules/Binary/ControlledOutputModule.cs

@@ -1,56 +1,48 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ControlledOutputModule : BinaryComputationalModule, IPolymorphismModule
+public partial class ControlledOutputModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
-    [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);
+    [Export] private StringName? PresetDataType { get; set; }
+    private IDataOutGroup? OutputGroup { get; set; }
+    public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
+    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
+    public void Inference() => DataInPorts[1].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.DataOutInit("Output", 4);
+        OutputGroup = GlobalProvider.DataStructureProvider!.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "Output Data Type",
-            UsingPreset ? PresetDataType : EnigmosConstant.DataPortTypes.Real,
+            UsingPreset ? PresetDataType! : EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.AnyType
         );
         ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
-        Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
-        Input2.SetDataType(EnigmosConstant.DataPortTypes.Real);
+        DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.Bit);
+        DataInPorts[1].SetDataType(EnigmosConstant.DataPortTypes.Real);
         PostInit();
     }
 
-
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        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
-                );
+        (object, StringName) Func(CacheItem cache)
+        {
+            if (this.X(cache).Bit) 
+                return (this.Y(cache).Data!, this.Y(cache).Type!);
+            return (0, EnigmosConstant.DataPortTypes.Null);
+        }
+
+        this.Define(Func);
     }
+    
 }

Modules/ComputationalModules/Binary/DivisionModule.cs

@@ -1,42 +1,37 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class DivisionModule : BinaryComputationalModule, IPolymorphismModule
+public partial class DivisionModule : BinaryComputationalModule, 
+    IPolymorphismModule,
+    IDuplicateOutputModule
 {
-    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 })!;
+    private IDataInGroup? InputGroup { get; set; }
+    private IDataOutGroup? OutputGroup { get; set; }
+    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     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.DataOutInit("Output", 4);
+        InputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new IDataPort[] { Input1, Input2 },
+            DataInPorts,
             "",
             EnigmosConstant.DataPortTypes.Real,
             Array.Empty<StringName>()
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "Output Port Type",
             EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.NumericTypes
@@ -45,17 +40,14 @@ public partial class DivisionModule : BinaryComputationalModule, IPolymorphismMo
         PostInit();
     }
 
-
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        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;
-        }
+        (object, StringName) Func(CacheItem cache) => 
+            GlobalProvider.PolymorphismProvider!.Div(this.X(cache), this.Y(cache));
+        this.Define(Func);
     }
+    
 
-    public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType;
+    public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;
     
 }

Modules/ComputationalModules/Binary/DotProductModule.cs

@@ -1,42 +1,36 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class DotProductModule : BinaryComputationalModule, IPolymorphismModule
+public partial class DotProductModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
-    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 })!;
+    private IDataInGroup? VectorInputGroup { get; set; }
+    private IDataOutGroup? OutputGroup { get; set; }
+
+    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     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.DataOutInit("Output", 4);
+        VectorInputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new IDataPort[] { Input1, Input2 },
+            DataInPorts,
             "Vector Input Type",
             EnigmosConstant.DataPortTypes.R2,
             EnigmosConstant.DataPortTypes.VectorTypes
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "",
             EnigmosConstant.DataPortTypes.Real,
             Array.Empty<StringName>()
@@ -45,14 +39,12 @@ public partial class DotProductModule : BinaryComputationalModule, IPolymorphism
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        IDataPackage res = GlobalProvider.PolymorphismProvider!.Dot(input1, input2, VectorInputGroup!.SelectedType);
-        foreach (IDataPort port in OutputGroup!)
-            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
-        
+        (object, StringName) Func(CacheItem cache) =>
+            GlobalProvider.PolymorphismProvider!.Dot(this.X(cache), this.Y(cache));
+        this.Define(Func);
     }
-    
 
     public void Inference()
     {

Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs

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

Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs

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

Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs

@@ -1,27 +1,21 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
-using TabulaSmaragdina.Constants;
+using Godot;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.GlobalManagement.Constants;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalConjunctionModule : BinaryComputationalModule
+public partial class LogicalConjunctionModule : BinaryLogicModule
 {
-	private DataOutPort Output1 { get; set; }
-	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
-	public override void Init()
+
+
+	public override void Define()
 	{
-		base.Init();
-		Output1 = GetPort<DataOutPort>("Output1");
-		Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
-		Input2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
-		Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
-		PostInit();
+		var x = DataOutPorts.Length;
+
+		(object, StringName) Func(CacheItem cache) =>
+			(this.X(cache).Bit & this.Y(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+		this.Define(Func);
 	}
 
-	protected override void Compute(IDataPackage input1, IDataPackage input2)
-	{
-		//Output1.DataUpdated = true;
-		Output1.ResultData.Bit = input1.Bit & input2.Bit;
-	}
 }

Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs

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

Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs

@@ -1,27 +1,17 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
-using TabulaSmaragdina.Constants;
+using Godot;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.GlobalManagement.Constants;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalExclusiveDisjunctionModule : BinaryComputationalModule
+public partial class LogicalExclusiveDisjunctionModule : BinaryLogicModule
 {
-	private DataOutPort Output1 { get; set; }
-	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
-	public override void Init()
+	public override void Define()
 	{
-		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;
+		(object, StringName) Func(CacheItem cache)
+			=> (this.X(cache).Bit ^ this.Y(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+		this.Define(Func);
 	}
+
 }

Modules/ComputationalModules/Binary/LogicalImplicationModule.cs

@@ -1,27 +1,14 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
-using TabulaSmaragdina.Constants;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalImplicationModule : BinaryComputationalModule
+public partial class LogicalImplicationModule : BinaryLogicModule
 {
-	private DataOutPort? Output1 { get; set; }
-	public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
-	public override void Init()
+	public override void Define()
 	{
-		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;
+		this.Define(
+			x => (!this.X(x).Bit | this.Y(x).Bit, EnigmosConstant.DataPortTypes.Bit)
+		);
 	}
 }

Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs

@@ -1,28 +1,18 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
-using TabulaSmaragdina.Constants;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.GlobalManagement.Constants;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalJointDenialModule : BinaryComputationalModule
+public partial class LogicalJointDenialModule : BinaryLogicModule
 {
-	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;
-	}
+    public override void Define()
+    {
+        this.Define(
+            x =>
+            (
+                !this.X(x).Bit & !this.Y(x).Bit,
+                EnigmosConstant.DataPortTypes.Bit
+            )
+        );
+    }
 }

Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs

@@ -1,28 +1,17 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
-using TabulaSmaragdina.Constants;
+using Godot;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.GlobalManagement.Constants;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class LogicalNonimplicationModule : BinaryComputationalModule
+public partial class LogicalNonimplicationModule : BinaryLogicModule
 {
-    private DataOutPort Output1 { get; set; }
-    public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
-    public override void Init()
+    public override void Define()
     {
-        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;
+        (object, StringName) Func(CacheItem cache) => 
+            (this.X(cache).Bit & !this.Y(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
+        this.Define(Func);
     }
+    
 }

Modules/ComputationalModules/Binary/MaxModule.cs

@@ -1,44 +1,32 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
-using TabulaSmaragdina.Constants;
+using Godot;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.GlobalManagement.Constants;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class MaxModule : BinaryComputationalModule
+public partial class MaxModule : BinaryComputationalModule, IOperationModule, IDuplicateOutputModule
 {
-    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 IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     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);
+        this.DataOutInit("Output", 3);
+        this.SetInputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        if (input1.Real > input2.Real)
+        (object, StringName) Func(CacheItem cache)
         {
-            Output1.ResultData.Real = input1.Real;
-            Output2.ResultData.Real = input1.Real;
-            Output3.ResultData.Real = input1.Real;
+            if (this.X(cache).Double > this.Y(cache).Double)
+                return (this.X(cache), EnigmosConstant.DataPortTypes.Real);
+            return (this.Y(cache), EnigmosConstant.DataPortTypes.Real);
         }
-        else
-        {
-            Output1.ResultData.Real = input2.Real;
-            Output2.ResultData.Real = input2.Real;
-            Output3.ResultData.Real = input2.Real;
-        }
-        
+        this.Define(Func);
     }
+    
 }

Modules/ComputationalModules/Binary/MinModule.cs

@@ -1,44 +1,31 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
-using Nocturnis.DataStructures;
-using TabulaSmaragdina.Constants;
+using Godot;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.GlobalManagement.Constants;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class MinModule : BinaryComputationalModule
+public partial class MinModule : BinaryComputationalModule, IDuplicateOutputModule, IOperationModule
 {
-    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 IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     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);
+        this.DataOutInit("Output", 3);
+        this.SetInputType(EnigmosConstant.DataPortTypes.Real);
+        this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        if (input1.Real < input2.Real)
+        (object, StringName) Func(CacheItem cache)
         {
-            Output1.ResultData.Real = input1.Real;
-            Output2.ResultData.Real = input1.Real;
-            Output3.ResultData.Real = input1.Real;
+            if (this.X(cache).Double < this.Y(cache).Double)
+                return (this.X(cache).Data!, this.X(cache).Type!);
+            return (this.Y(cache).Data!, this.Y(cache).Type!);
         }
-        else
-        {
-            Output1.ResultData.Real = input2.Real;
-            Output2.ResultData.Real = input2.Real;
-            Output3.ResultData.Real = input2.Real;
-        }
-
+        this.Define(Func);
     }
 }

Modules/ComputationalModules/Binary/MultiplicationModule.cs

@@ -1,41 +1,37 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
+using Nocturnis.Enigmos.Ports;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class MultiplicationModule : BinaryComputationalModule, IPolymorphismModule
+public partial class MultiplicationModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
-    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; }
+    private IDataPortGroup? InputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+
+    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
+    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.DataOutInit("Output", 4);
+
+        InputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new DataPort[] { Input1, Input2 },
+            DataInPorts,
             "",
             EnigmosConstant.DataPortTypes.Real,
             Array.Empty<StringName>()
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new DataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "Output Port Type",
             EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.NumericTypes
@@ -44,13 +40,13 @@ public partial class MultiplicationModule : BinaryComputationalModule, IPolymorp
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        IDataPackage res = GlobalProvider.PolymorphismProvider.Mul(input1, input2, OutputGroup.SelectedType);
-        foreach (DataPort port in OutputGroup)
-            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+        (object, StringName) Func(CacheItem cache) => 
+            GlobalProvider.PolymorphismProvider!.Mul(this.X(cache), this.Y(cache));
+        this.Define(Func);
     }
 
-    public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType;
+    public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;
 
 }

Modules/ComputationalModules/Binary/PowerModule.cs

@@ -1,43 +1,37 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class PowerModule : BinaryComputationalModule, IPolymorphismModule
+public partial class PowerModule : BinaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
 {
     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 IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     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.DataOutInit("Output", 4);
+        TensorInputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new IDataPort[] { Input1 },
+            new IDataInPort[] { DataInPorts[0] },
             "Base Tensor Type",
             EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.NumericTypes
         );
-        Input2.SetDataType(EnigmosConstant.DataPortTypes.Complex);
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        DataInPorts[1].SetDataType(EnigmosConstant.DataPortTypes.Complex);
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "",
             EnigmosConstant.DataPortTypes.Real,
             Array.Empty<StringName>()
@@ -46,18 +40,13 @@ public partial class PowerModule : BinaryComputationalModule, IPolymorphismModul
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        
-        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;
-        }
+        (object, StringName) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.Pow(this.X(cache), this.Y(cache));
+        this.Define(Func);
     }
 
     public void Inference() => 
-        OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.ComplexVersionOf(TensorInputGroup.SelectedType);
+        OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.ComplexVersionOf(TensorInputGroup!.SelectedType);
 
 }

Modules/ComputationalModules/Binary/ScalarDivisionModule.cs

@@ -1,24 +1,23 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ScalarDivisionModule : BinaryComputationalModule, IPolymorphismModule, IErrorHandlerModule
+public partial class ScalarDivisionModule : BinaryComputationalModule, 
+    IPolymorphismModule,
+    IDuplicateOutputModule
 {
     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 IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public override double MaintenanceAlpha => 0.77852142d;
     public override double MaintenanceBeta => 0.9544432d;
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
@@ -26,27 +25,24 @@ public partial class ScalarDivisionModule : BinaryComputationalModule, IPolymorp
     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.DataOutInit("Output", 4);
+        TensorInputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new IDataPort[] { Input1 },
+            new IDataInPort[] { DataInPorts[0] },
             "Tensor Input Type",
             EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.VectorTypes
         );
-        ScalarInputGroup =GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        ScalarInputGroup =GlobalProvider.DataStructureProvider.NewDataInGroup(
             this,
-            new IDataPort[] { Input2 },
+            new IDataInPort[] { DataInPorts[1] },
             "Scalar Input Type",
             EnigmosConstant.DataPortTypes.R2,
             EnigmosConstant.DataPortTypes.VectorTypes
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "",
             EnigmosConstant.DataPortTypes.Real,
             Array.Empty<StringName>()
@@ -56,68 +52,21 @@ public partial class ScalarDivisionModule : BinaryComputationalModule, IPolymorp
         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 override void Define()
+    {
+        (object, StringName) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.ScalarDiv(this.X(cache), this.Y(cache));
+        this.Define(Func);
     }
 
     public void Inference()
     {
-        if (GlobalProvider.DataPackageTypeProvider.IsComplexTensorType(ScalarInputGroup.SelectedType))
-            OutputGroup.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup.SelectedType);
+        if (GlobalProvider.DataPackageTypeProvider!.IsComplexTensorType(ScalarInputGroup!.SelectedType))
+            OutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider.ComplexVersionOf(TensorInputGroup!.SelectedType);
         else
-            OutputGroup.SelectedType = TensorInputGroup.SelectedType;
+            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

@@ -1,50 +1,47 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.Enigmos.Ports.DataPorts.Directions;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class ScalarMultiplicationModule : BinaryComputationalModule, IPolymorphismModule
+public partial class ScalarMultiplicationModule : 
+    BinaryComputationalModule, 
+    IPolymorphismModule,
+    IDuplicateOutputModule
 {
     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 IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     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.DataOutInit("Output",4);
+        ScalarInputGroup =  GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new IDataPort[] { Input1 },
+            new IDataInPort[] { DataInPorts[0] },
             "Scalar Input Type",
             EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.NumericTypes
         );
-        TensorInputGroup =  GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        TensorInputGroup =  GlobalProvider.DataStructureProvider.NewDataInGroup(
             this,
-            new IDataPort[] { Input2 },
+            new IDataInPort[] { DataInPorts[1] },
             "Tensor Input Type",
             EnigmosConstant.DataPortTypes.R2,
             EnigmosConstant.DataPortTypes.VectorTypes
         );
-        OutputGroup =  GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup =  GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "",
             EnigmosConstant.DataPortTypes.Real,
             Array.Empty<StringName>()
@@ -53,14 +50,12 @@ public partial class ScalarMultiplicationModule : BinaryComputationalModule, IPo
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+
+    public override void Define()
     {
-        IDataPackage res = 
-            GlobalProvider.PolymorphismProvider!
-                .ScalarMul(input1, input2, ScalarInputGroup!.SelectedType, TensorInputGroup!.SelectedType);
-        foreach (IDataPort port in OutputGroup!)
-            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
-            
+        (object, StringName) Func(CacheItem cache) => 
+            GlobalProvider.PolymorphismProvider!.ScalarMul(this.X(cache), this.Y(cache));
+        this.Define(Func);
     }
 
     public void Inference()
@@ -73,5 +68,5 @@ public partial class ScalarMultiplicationModule : BinaryComputationalModule, IPo
         else
             OutputGroup!.SelectedType = TensorInputGroup.SelectedType;
     }
+}
 
-}

Modules/ComputationalModules/Binary/SubtractionModule.cs

@@ -1,43 +1,38 @@
-using Enigmos.Ports;
-using Enigmos.Ports.DataPorts;
 using Godot;
-using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 
 namespace Enigmos.Modules.ComputationalModules.Binary;
 
-public partial class SubtractionModule : BinaryComputationalModule, IPolymorphismModule
+public partial class SubtractionModule : BinaryComputationalModule,
+    IPolymorphismModule,
+    IDuplicateOutputModule
 {
-    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; }
+    private IDataPortGroup? InputGroup { get; set; }
+    private IDataPortGroup? OutputGroup { get; set; }
+    public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
+
+    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.DataOutInit("Output", 4);
+        InputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new IDataPort[] { Input1, Input2 },
+            DataInPorts,
             "",
             EnigmosConstant.DataPortTypes.Real,
             Array.Empty<StringName>()
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "Output Port Type",
             EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.AnyTensor
@@ -46,13 +41,12 @@ public partial class SubtractionModule : BinaryComputationalModule, IPolymorphis
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        IDataPackage res = GlobalProvider.PolymorphismProvider.Sub(input1, input2, OutputGroup.SelectedType);
-        foreach (DataPort port in OutputGroup)
-            (port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
+        (object, StringName) Func(CacheItem cache) => GlobalProvider.PolymorphismProvider!.Sub(this.X(cache), this.Y(cache));
     }
 
-    public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType;
+
+    public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;
 
 }

Modules/ComputationalModules/Binary/V2Module.cs

@@ -1,17 +1,21 @@
-using Enigmos.Ports;
 using Enigmos.Ports.DataPorts;
 using Godot;
 using Nocturnis.DataStructures;
+using Nocturnis.DataStructures.DataPortGroups;
 using Nocturnis.Enigmos.Modules;
+using Nocturnis.Enigmos.Modules.ComputationalModules;
 using Nocturnis.Enigmos.Ports;
-using TabulaSmaragdina;
-using TabulaSmaragdina.Constants;
+using Nocturnis.GlobalManagement.Constants;
+using Nocturnis.GlobalManagement.Providers;
+using Skeleton.DataStructure;
 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
+public partial class V2Module : BinaryComputationalModule, 
+    IPolymorphismModule,
+    IDuplicateOutputModule
 {
     private IDataPortGroup? ScalarInputGroup { get; set; }
     private IDataPortGroup? OutputGroup { get; set; }
@@ -19,7 +23,7 @@ public partial class V2Module : BinaryComputationalModule, IPolymorphismModule
     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 IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
     public override double MaintenanceAlpha => 0.77852142d;
     public override double MaintenanceBeta => 0.9544432d;
     public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
@@ -27,20 +31,17 @@ public partial class V2Module : BinaryComputationalModule, IPolymorphismModule
     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.DataOutInit("Output", 4);
+        ScalarInputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
             this,
-            new IDataPort[] { Input1, Input2 },
+            DataInPorts,
             "Scalar Input Type",
             EnigmosConstant.DataPortTypes.Real,
             EnigmosConstant.DataPortTypes.NumericTypes
         );
-        OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
+        OutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
             this,
-            new IDataPort[] { Output1, Output2, Output3, Output4 },
+            DataOutPorts,
             "",
             EnigmosConstant.DataPortTypes.R2,
             Array.Empty<StringName>()
@@ -49,17 +50,18 @@ public partial class V2Module : BinaryComputationalModule, IPolymorphismModule
         PostInit();
     }
 
-    protected override void Compute(IDataPackage input1, IDataPackage input2)
+    public override void Define()
     {
-        R2 v2R = new R2(input1.Real, input2.Real);
-        C2 v2C = new C2(input1.Complex, input2.Complex);
-        foreach (IDataPort port in OutputGroup!)
+        (object, StringName) Func(CacheItem cache)
         {
-            if (ScalarInputGroup!.SelectedType == EnigmosConstant.DataPortTypes.Real)
-                (port as DataOutPort)!.ResultData.R2 = v2R;
-            else 
-                (port as DataOutPort)!.ResultData.C2 = v2C;
+            IData x = this.X(cache);
+            IData y = this.Y(cache);
+            
+            if (x.Type == EnigmosConstant.DataPortTypes.Complex || y.Type == EnigmosConstant.DataPortTypes.Complex)
+                return (new C2(x.Complex, y.Complex), EnigmosConstant.DataPortTypes.C2);
+            return (new R2(x.Double, y.Double), EnigmosConstant.DataPortTypes.Real);
         }
+        this.Define(Func);
     }
 
     public void Inference()