hzhang/Enigmos
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Upgrade structure of code base

Browse Source
This commit is contained in:
h z
2024-07-03 12:20:08 +08:00
parent 59d257c06a
commit be5428d708
91 changed files with 1742 additions and 1603 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
Modules/ComputationalModules/Binary/AdditionModule.cs
View File

@@ -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);
}
}

17
Modules/ComputationalModules/Binary/BinaryLogicModule.cs Normal file
View File

@@ -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();
}
}

41
Modules/ComputationalModules/Binary/ComparisionModule.cs
View File

@@ -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
)
);
}
}

62
Modules/ComputationalModules/Binary/ControlledOutputModule.cs
View File

@@ -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);
}
}

52
Modules/ComputationalModules/Binary/DivisionModule.cs
View File

@@ -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;
}

46
Modules/ComputationalModules/Binary/DotProductModule.cs
View File

@@ -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()
{

29
Modules/ComputationalModules/Binary/LogicalAlternativeDenialModule.cs
View File

@@ -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;
}
}

31
Modules/ComputationalModules/Binary/LogicalBiconditionalModule.cs
View File

@@ -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);
}
}

32
Modules/ComputationalModules/Binary/LogicalConjunctionModule.cs
View File

@@ -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;
}
}

29
Modules/ComputationalModules/Binary/LogicalDisjunctionModule.cs
View File

@@ -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;
}
}

30
Modules/ComputationalModules/Binary/LogicalExclusiveDisjunctionModule.cs
View File

@@ -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);
}
}

27
Modules/ComputationalModules/Binary/LogicalImplicationModule.cs
View File

@@ -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)
);
}
}

36
Modules/ComputationalModules/Binary/LogicalJointDenialModule.cs
View File

@@ -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
)
);
}
}

31
Modules/ComputationalModules/Binary/LogicalNonimplicationModule.cs
View File

@@ -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);
}
}

46
Modules/ComputationalModules/Binary/MaxModule.cs
View File

@@ -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);
}
}

45
Modules/ComputationalModules/Binary/MinModule.cs
View File

@@ -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);
}
}

50
Modules/ComputationalModules/Binary/MultiplicationModule.cs
View File

@@ -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;
}

47
Modules/ComputationalModules/Binary/PowerModule.cs
View File

@@ -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);
}

105
Modules/ComputationalModules/Binary/ScalarDivisionModule.cs
View File

@@ -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; }
}
}

53
Modules/ComputationalModules/Binary/ScalarMultiplicationModule.cs
View File

@@ -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;
}
}
}

50
Modules/ComputationalModules/Binary/SubtractionModule.cs
View File

@@ -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;
}

44
Modules/ComputationalModules/Binary/V2Module.cs
View File

@@ -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()

24
Modules/ComputationalModules/BinaryComputationalModule.cs
View File

@@ -1,26 +1,18 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ComputationalModules;
public abstract partial class BinaryComputationalModule : ComputationalModule
public abstract partial class BinaryComputationalModule : ComputationalModule, IBinaryComputationalModule
{
protected DataInPort Input1 { get; set; }
protected DataInPort Input2 { get; set; }
public override IEnumerable<BasePort> Ports => new[] { Input1, Input2 };
public override IEnumerable<IBasePort> Ports => DataInPorts;
public IDataInPort[] DataInPorts { get; set; } = new IDataInPort[2];
public override void Init()
{
base.Init();
Input1 = GetPort<DataInPort>("Input1");
Input2 = GetPort<DataInPort>("Input2");
this.BinaryInit();
}
protected abstract void Compute(IDataPackage input1, IDataPackage input2);
protected override void Compute(IRootModule root) => Compute(Input1.GetData(root), Input2.GetData(root));
}
}

29
Modules/ComputationalModules/ComputationalModule.cs
View File

@@ -1,32 +1,13 @@
using Enigmos.Exceptions;
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports.DataPorts;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ComputationalModules;
public abstract partial class ComputationalModule : BaseModule
public abstract partial class ComputationalModule : BaseModule, IComputationalModule
{
protected override void TimeoutHandler(ModuleExecutionTimeout timeout)
{
foreach (DataOutPort port in Ports.OfType<DataOutPort>())
port.DataUpdated = false;
base.TimeoutHandler(timeout);
}
public IDataOutPort[] DataOutPorts { get; set; } = Array.Empty<IDataOutPort>();
public abstract void Define();
protected abstract void Compute(IRootModule root);
public void ComputeWithTimeoutHandle(IRootModule root)
{
foreach (DataOutPort port in Ports.OfType<DataOutPort>())
port.DataUpdated = true;
try
{
Compute(root);
}
catch (ModuleExecutionTimeout timeOut)
{
TimeoutHandler(timeOut);
}
TimeoutCheck(root);
}
}

40
Modules/ComputationalModules/Nullary/ConstantModule.cs
View File

@@ -1,39 +1,27 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Godot;
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.Nullary;
public partial class ConstantModule : NullaryComputationalModule, IParameterizedModule
public partial class ConstantModule : NullaryComputationalModule, IParameterizedModule, IDuplicateOutputModule
{
[Export] private double PresetConstantValue { get; set; }
private HashSet<DataOutPort> OutputGroup { get; set; } = new();
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 IDoubleParameter ConstValue { get; set; }
public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
private IDoubleParameter? ConstValue { get; set; }
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);
this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
OutputGroup = new HashSet<DataOutPort>(new[] { Output1, Output2, Output3, Output4 });
foreach (DataOutPort port in OutputGroup)
port.SetDataType(EnigmosConstant.DataPortTypes.Real);
ConstValue =
GlobalProvider.DataStructureProvider.NewDoubleParameter(
GlobalProvider.DataStructureProvider!.NewDoubleParameter(
"Constant Value",
-1,
1,
@@ -43,11 +31,11 @@ public partial class ConstantModule : NullaryComputationalModule, IParameterized
PostInit();
}
protected override void Compute(IRootModule root)
public override void Define()
{
foreach (DataOutPort port in OutputGroup)
port.ResultData.Real = ConstValue.ParameterValue;
this.Define(cache =>
(ConstValue!.ParameterValue, EnigmosConstant.DataPortTypes.Real)
);
}
public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();

33
Modules/ComputationalModules/Nullary/KeyListenerModule.cs
View File

@@ -1,14 +1,18 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Godot;
using Nocturnis.DataStructures.ConfigurableParameters;
using Nocturnis.Enigmos.Modules;
using TabulaSmaragdina;
using TabulaSmaragdina.Constants;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;
using Skeleton.DataStructure;
namespace Enigmos.Modules.ComputationalModules.Nullary;
public partial class KeyListenerModule : NullaryComputationalModule, IParameterizedModule, IKeyListenerModule
public partial class KeyListenerModule : NullaryComputationalModule,
IParameterizedModule,
IKeyListenerModule,
IDuplicateOutputModule
{
[Export] private StringName? PresetActionName { get; set; }
private DataOutPort? Output1 { get; set; }
@@ -18,22 +22,11 @@ public partial class KeyListenerModule : NullaryComputationalModule, IParameteri
public bool Pressed { get; set; }
public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
public override IEnumerable<BasePort> Ports => new[] { Output1, Output2, Output3 }!;
protected override void Compute(IRootModule root)
{
Output1!.ResultData.Bit = Pressed;
Output2!.ResultData.Bit = Pressed;
Output3!.ResultData.Bit = Pressed;
}
public override void Init()
{
base.Init();
Output1 = GetPort<DataOutPort>("Output1");
Output2 = GetPort<DataOutPort>("Output2");
Output3 = GetPort<DataOutPort>("Output3");
Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Output2.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Output3.SetDataType(EnigmosConstant.DataPortTypes.Bit);
this.DataOutInit("Output", 3);
this.SetOutputType(EnigmosConstant.DataPortTypes.Bit);
ListeningKey = GlobalProvider.DataStructureProvider!.NewKeyParameter(
"Listening Key",
UsingPreset && (PresetActionName != null) ? PresetActionName : "KeyListenAction"
@@ -48,4 +41,10 @@ public partial class KeyListenerModule : NullaryComputationalModule, IParameteri
GlobalProvider.SceneProvider!.RootScene.KeyListener.Register(this);
PostInit();
}
public override void Define()
{
(object item, StringName type) Func(CacheItem cache) => (Pressed, EnigmosConstant.DataPortTypes.Bit);
this.Define(Func);
}
}

34
Modules/ComputationalModules/Nullary/NormalDistributionModule.cs
View File

@@ -1,23 +1,26 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures.ConfigurableParameters;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;
using Skeleton.Utils.RandomEngines;
using TabulaSmaragdina;
using TabulaSmaragdina.Constants;
namespace Enigmos.Modules.ComputationalModules.Nullary;
public partial class NormalDistributionModule : NullaryComputationalModule, IParameterizedModule
public partial class NormalDistributionModule : NullaryComputationalModule,
IParameterizedModule,
IDuplicateOutputModule
{
private HashSet<DataOutPort> OutputGroup { get; set; } = new();
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);
private IDoubleParameter? Mu { get; set; }
private IDoubleParameter? Sigma { get; set; }
@@ -25,27 +28,24 @@ public partial class NormalDistributionModule : NullaryComputationalModule, IPar
public override void Init()
{
base.Init();
Output1 = GetPort<DataOutPort>("Output1");
Output2 = GetPort<DataOutPort>("Output2");
Output3 = GetPort<DataOutPort>("Output3");
Output4 = GetPort<DataOutPort>("Output4");
OutputGroup = new HashSet<DataOutPort>(new[] { Output1, Output2, Output3, Output4 });
foreach (DataOutPort port in OutputGroup)
port.SetDataType(EnigmosConstant.DataPortTypes.Real);
this.DataOutInit("Output", 4);
this.SetOutputType(EnigmosConstant.DataPortTypes.Real);
Mu = GlobalProvider.DataStructureProvider!.NewDoubleParameter("mu", -1, 1, 0);
Sigma = GlobalProvider.DataStructureProvider.NewDoubleParameter("sigma", 0, 2, 1);
ConfigurableParameters = new HashSet<IConfigurableParameter> { Mu, Sigma };
PostInit();
}
protected override void Compute(IRootModule root)
public override void Define()
{
foreach (DataOutPort port in OutputGroup)
foreach (IDataOutPort op in DataOutPorts)
{
port.ResultData.Real = Normal.Get() * Sigma.ParameterValue - Mu.ParameterValue;
op.OutData.UpdateCalculation(x =>
(Normal.Get() * Sigma!.ParameterValue - Mu!.ParameterValue, EnigmosConstant.DataPortTypes.Real)
);
}
}
public HashSet<IConfigurableParameter> ConfigurableParameters { get; set; } = new();
}

6
Modules/ComputationalModules/NullaryComputationalModule.cs
View File

@@ -1,8 +1,10 @@
using Enigmos.Ports;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
namespace Enigmos.Modules.ComputationalModules;
public abstract partial class NullaryComputationalModule : ComputationalModule
public abstract partial class NullaryComputationalModule : ComputationalModule, ISourceModule
{
public override IEnumerable<BasePort> Ports => Array.Empty<BasePort>();
public override IEnumerable<IBasePort> Ports => Array.Empty<BasePort>();
}

47
Modules/ComputationalModules/Ternary/SelectorModule.cs
View File

@@ -1,43 +1,48 @@
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures;
using Godot;
using Nocturnis.DataStructures.DataPortGroups;
using Nocturnis.Enigmos.Modules;
using TabulaSmaragdina;
using TabulaSmaragdina.Constants;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts;
using Nocturnis.GlobalManagement.Constants;
using Nocturnis.GlobalManagement.Providers;
using Skeleton.DataStructure;
namespace Enigmos.Modules.ComputationalModules.Ternary;
public partial class SelectorModule : TernaryComputationalModule, IPolymorphismModule
public partial class SelectorModule : TernaryComputationalModule,
ITernaryComputationalModule,
IPolymorphismModule,
IDuplicateOutputModule
{
private DataOutPort? Output1 { get; set; }
private DataOutPort? Output2 { get; set; }
private DataOutPort? Output3 { get; set; }
private IDataPortGroup? DataTypeGroup { get; set; }
public HashSet<IDataPortGroup> ConfigurablePortGroups { get; set; } = new();
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");
DataTypeGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
this.DataOutInit("Output", 3);
DataTypeGroup = GlobalProvider.DataStructureProvider!.NewDataPortGroup(
this,
new DataPort[] { Input2, Input3, Output1, Output2, Output3 },
new IDataPort[]{DataInPorts[1], DataInPorts[2]}.Union(DataOutPorts).ToArray(),
"Data Type",
EnigmosConstant.DataPortTypes.Real,
EnigmosConstant.DataPortTypes.AnyType
);
Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
DataInPorts[0].SetDataType(EnigmosConstant.DataPortTypes.Bit);
PostInit();
}
protected override void Compute(IDataPackage input1, IDataPackage input2, IDataPackage input3)
public override void Define()
{
Output1!.ResultData.Assign(input1.Bit ? input2 : input3, DataTypeGroup.SelectedType);
Output2!.ResultData.Assign(input1.Bit ? input2 : input3, DataTypeGroup.SelectedType);
Output3!.ResultData.Assign(input1.Bit ? input2 : input3, DataTypeGroup.SelectedType);
(object, StringName) Func(CacheItem cache)
{
if (this.X(cache).Bit)
return (this.Y(cache).Data!, this.Y(cache).Type!);
return (this.Z(cache).Data!, this.Z(cache).Type!);
}
this.Define(Func);
}
public void Inference()

22
Modules/ComputationalModules/TernaryComputationalModule.cs
View File

@@ -1,27 +1,17 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ComputationalModules;
public abstract partial class TernaryComputationalModule : ComputationalModule
public abstract partial class TernaryComputationalModule : ComputationalModule, IParameterModule
{
protected DataInPort? Input1 { get; set; }
protected DataInPort? Input2 { get; set; }
protected DataInPort? Input3 { get; set; }
public override IEnumerable<BasePort> Ports => new[] { Input1, Input2, Input3 }!;
public IDataInPort[] DataInPorts { get; set; } = new IDataInPort[3];
public override IEnumerable<IBasePort> Ports => DataInPorts;
public override void Init()
{
base.Init();
Input1 = GetPort<DataInPort>("Input1");
Input2 = GetPort<DataInPort>("Input2");
Input3 = GetPort<DataInPort>("Input3");
this.DataInInit("Input", 3);
}
protected abstract void Compute(IDataPackage input1, IDataPackage input2, IDataPackage input3);
protected override void Compute(IRootModule root) =>
Compute(Input1.GetData(root), Input2.GetData(root), Input3.GetData(root));
}

42
Modules/ComputationalModules/Unary/CopyModule.cs
View File

@@ -1,40 +1,35 @@
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.Unary;
public partial class CopyModule : UnaryComputationalModule, IPolymorphismModule
public partial class CopyModule : UnaryComputationalModule,
IPolymorphismModule,
IDuplicateOutputModule
{
private DataOutPort? Output1 { get; set; }
private DataOutPort? Output2 { get; set; }
private DataOutPort? Output3 { get; set; }
private DataOutPort? Output4 { get; set; }
private IDataPortGroup? InputGroup { get; set; }
private IDataPortGroup? OutputGroup { 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");
InputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
this.DataOutInit("Output", 4);
InputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
this,
new IDataPort[] {Input1},
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.AnyType
@@ -42,15 +37,12 @@ public partial class CopyModule : UnaryComputationalModule, IPolymorphismModule
ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
PostInit();
}
protected override void Compute(IDataPackage input1)
public override void Define()
{
foreach (IDataPort port in OutputGroup!)
(port as DataOutPort)!.ResultData.Assign(input1, OutputGroup.SelectedType);
(object, StringName) Func(CacheItem cache) => (this.X(cache).Data, this.X(cache).Type)!;
this.Define(Func);
}
public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;
}

29
Modules/ComputationalModules/Unary/LogicalNegationModule.cs
View File

@@ -1,26 +1,27 @@
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.Unary;
public partial class LogicalNegationModule : UnaryComputationalModule
public partial class LogicalNegationModule : UnaryComputationalModule, IDuplicateOutputModule
{
private DataOutPort Output1 { get; set; }
public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1 });
public override IEnumerable<IBasePort> Ports => base.Ports.Union(DataOutPorts);
public override void Init()
{
base.Init();
Output1 = GetPort<DataOutPort>("Output1");
Input1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
Output1.SetDataType(EnigmosConstant.DataPortTypes.Bit);
this.DataOutInit("Output", 1);
this.SetInputType(EnigmosConstant.DataPortTypes.Bit);
this.SetOutputType(EnigmosConstant.DataPortTypes.Bit);
PostInit();
}
protected override void Compute(IDataPackage input1)
public override void Define()
{
Output1.ResultData.Bit = !input1.Bit;
(object, StringName) Func(CacheItem cache) => (!this.X(cache).Bit, EnigmosConstant.DataPortTypes.Bit);
this.Define(Func);
}
}

41
Modules/ComputationalModules/Unary/NegationModule.cs
View File

@@ -1,42 +1,40 @@
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.Unary;
public partial class NegationModule : UnaryComputationalModule, IPolymorphismModule
public partial class NegationModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
{
private DataOutPort? Output1 { get; set; }
private DataOutPort? Output2 { get; set; }
private DataOutPort? Output3 { get; set; }
private DataOutPort? Output4 { get; set; }
private IDataPortGroup? InputGroup { get; set; }
private IDataPortGroup? OutputGroup { 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},
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 +44,12 @@ public partial class NegationModule : UnaryComputationalModule, IPolymorphismMod
}
protected override void Compute(IDataPackage input1)
public override void Define()
{
IDataPackage res = GlobalProvider.PolymorphismProvider.Neg(input1, OutputGroup.SelectedType);
foreach (IDataPort port in OutputGroup)
(port as DataOutPort)!.ResultData.Assign(res, OutputGroup.SelectedType);
(object, StringName) Func(CacheItem c) =>
GlobalProvider.PolymorphismProvider!.Neg(this.X(c));
this.Define(Func);
}
public void Inference() => InputGroup.SelectedType = OutputGroup.SelectedType;
public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;
}

43
Modules/ComputationalModules/Unary/SquareModule.cs
View File

@@ -1,43 +1,35 @@
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.Unary;
public partial class SquareModule : UnaryComputationalModule, IPolymorphismModule
public partial class SquareModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
{
private DataOutPort? Output1 { get; set; }
private DataOutPort? Output2 { get; set; }
private DataOutPort? Output3 { get; set; }
private DataOutPort? Output4 { get; set; }
private IDataPortGroup? InputGroup { get; set; }
private IDataPortGroup? OutputGroup { get; set; }
public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2, Output3, Output4 })!;
public HashSet<IDataPortGroup> ConfigurablePortGroups { 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},
DataInPorts,
"",
EnigmosConstant.DataPortTypes.Real,
Array.Empty<StringName>()
);
OutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
this,
new DataPort[] { Output1, Output2, Output3, Output4 },
DataOutPorts,
"Output Port Type",
EnigmosConstant.DataPortTypes.Real,
EnigmosConstant.DataPortTypes.NumericTypes
@@ -45,14 +37,11 @@ public partial class SquareModule : UnaryComputationalModule, IPolymorphismModul
ConfigurablePortGroups = new HashSet<IDataPortGroup> { OutputGroup };
PostInit();
}
protected override void Compute(IDataPackage input1)
public override void Define()
{
IDataPackage res = GlobalProvider.PolymorphismProvider.Square(input1, OutputGroup.SelectedType);
foreach (DataOutPort port in OutputGroup.OfType<DataOutPort>())
port.ResultData.Assign(res, OutputGroup.SelectedType);
(object, StringName) Func(CacheItem c) => GlobalProvider.PolymorphismProvider!.Square(this.X(c));
this.Define(Func);
}
public void Inference() => InputGroup!.SelectedType = OutputGroup!.SelectedType;

52
Modules/ComputationalModules/Unary/V2ComponentModule.cs
View File

@@ -1,39 +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.Unary;
public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphismModule
public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphismModule, IDuplicateOutputModule
{
private IDataPortGroup? VectorInputGroup { get; set; }
private IDataPortGroup? ScalarOutputGroup { get; set; }
private DataOutPort? Output1 { get; set; }
private DataOutPort? Output2 { get; set; }
public override IEnumerable<BasePort> Ports => base.Ports.Union(new[] { Output1, Output2 })!;
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");
VectorInputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
this.DataOutInit("Output", 2);
VectorInputGroup = GlobalProvider.DataStructureProvider!.NewDataInGroup(
this,
new IDataPort[] { Input1 },
DataInPorts,
"Vector Input Type",
EnigmosConstant.DataPortTypes.R2,
EnigmosConstant.DataPortTypes.VectorTypes
);
ScalarOutputGroup = GlobalProvider.DataStructureProvider.NewDataPortGroup(
ScalarOutputGroup = GlobalProvider.DataStructureProvider.NewDataOutGroup(
this,
new IDataPort[] { Output1, Output2 },
DataOutPorts,
"",
EnigmosConstant.DataPortTypes.Real,
Array.Empty<StringName>()
@@ -42,20 +41,29 @@ public partial class V2ComponentModule : UnaryComputationalModule, IPolymorphism
PostInit();
}
protected override void Compute(IDataPackage input1)
public override void Define()
{
if (VectorInputGroup!.SelectedType == EnigmosConstant.DataPortTypes.R2)
(object, StringName) Func1(CacheItem c)
{
Output1!.ResultData.Real = input1.R2[1];
Output2!.ResultData.Real = input1.R2[2];
IData v = this.X(c);
if (v.Type == EnigmosConstant.DataPortTypes.R2)
return (v.R2[1], EnigmosConstant.DataPortTypes.Real);
return (v.C2[1], EnigmosConstant.DataPortTypes.Complex);
}
else
(object, StringName) Func2(CacheItem c)
{
Output1!.ResultData.Complex = input1.C2[1];
Output2!.ResultData.Complex = input1.C2[2];
IData v = this.X(c);
if (v.Type == EnigmosConstant.DataPortTypes.R2)
return (v.R2[2], EnigmosConstant.DataPortTypes.Real);
return (v.C2[2], EnigmosConstant.DataPortTypes.Complex);
}
DataOutPorts[0].OutData.UpdateCalculation(Func1);
DataOutPorts[1].OutData.UpdateCalculation(Func2);
}
public void Inference() =>
ScalarOutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!.GetBaseField(VectorInputGroup.SelectedType);
ScalarOutputGroup!.SelectedType = GlobalProvider.DataPackageTypeProvider!
.GetBaseField(VectorInputGroup!.SelectedType);
}

17
Modules/ComputationalModules/UnaryComputationalModule.cs
View File

@@ -1,21 +1,18 @@
using Enigmos.Modules.ControllingModules;
using Enigmos.Ports;
using Enigmos.Ports.DataPorts;
using Nocturnis.DataStructures;
using Nocturnis.Enigmos.Modules;
using Nocturnis.Enigmos.Modules.ComputationalModules;
using Nocturnis.Enigmos.Ports;
using Nocturnis.Enigmos.Ports.DataPorts.Directions;
namespace Enigmos.Modules.ComputationalModules;
public abstract partial class UnaryComputationalModule : ComputationalModule
public abstract partial class UnaryComputationalModule : ComputationalModule, IUnaryComputationalModule
{
protected DataInPort? Input1 { get; set; }
public override IEnumerable<BasePort> Ports => new[] { Input1 }!;
public IDataInPort[] DataInPorts { get; set; } = new IDataInPort[1];
public override IEnumerable<IBasePort> Ports => DataInPorts;
public override void Init()
{
base.Init();
Input1 = GetPort<DataInPort>("Input1");
this.DataInInit("Input", 1);
}
protected abstract void Compute(IDataPackage input1);
protected override void Compute(IRootModule root) => Compute(Input1.GetData(root));
}