Upload folder using huggingface_hub

AIMA.csproj

@@ -0,0 +1,8 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net6.0</TargetFramework>
+  </PropertyGroup>
+
+</Project>

AIMA.sln

@@ -0,0 +1,25 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio Version 16
+VisualStudioVersion = 16.0.31605.320
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "AIMA", "AIMA.csproj", "{EC1DC4B7-A05B-47CD-ACA0-66FEA4A4ACBC}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{EC1DC4B7-A05B-47CD-ACA0-66FEA4A4ACBC}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{EC1DC4B7-A05B-47CD-ACA0-66FEA4A4ACBC}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{EC1DC4B7-A05B-47CD-ACA0-66FEA4A4ACBC}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{EC1DC4B7-A05B-47CD-ACA0-66FEA4A4ACBC}.Release|Any CPU.Build.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+	GlobalSection(ExtensibilityGlobals) = postSolution
+		SolutionGuid = {0CCF8634-28A7-43E8-B48C-8A69F54E8165}
+	EndGlobalSection
+EndGlobal

Agent/Action/IAction.cs

@@ -0,0 +1,7 @@
+namespace AIMA.Agent.Action
+{
+    public interface IAction
+    {
+        bool IsNoOperation();
+    }
+}

Agent/Action/NoOpAction.cs

@@ -0,0 +1,11 @@
+using AIMA.Agent.Action.Dynamic;
+
+namespace AIMA.Agent.Action
+{
+    public sealed class NoOpAction : DynamicAction
+    {
+        internal static readonly NoOpAction NO_OPERATION = new();
+        public override bool IsNoOperation() => true;
+        private NoOpAction() : base("NoOp") {}
+    }
+}

Agent/AgentBase.cs

@@ -0,0 +1,26 @@
+using AIMA.Agent.Action;
+using AIMA.Agent.Percept;
+using AIMA.Agent.Program;
+
+namespace AIMA.Agent
+{
+    public abstract class AgentBase<T1,T2> : IAgent<T1,T2> where T1: IAction where T2: IPercept
+    {
+        protected readonly IAgentProgram<T1,T2> _agentProgram;
+        protected AgentBase(IAgentProgram<T1, T2> agentProgram)
+        {
+            _agentProgram = agentProgram;
+        }
+        private bool Alive { get; set; }
+        public virtual T1 Execute(T2 percept)
+        {
+            if(_agentProgram is not null)
+            {
+                return _agentProgram.Execute(percept);
+            }
+            return (T1)(NoOpAction.NO_OPERATION as IAction);
+        }
+        public bool IsAlive() => Alive;
+        public virtual void SetAlive(bool alive) => Alive = alive;
+    }
+}

Agent/Dynamic/DynamicAction.cs

@@ -0,0 +1,13 @@
+using AIMA.Agent.Object;
+
+namespace AIMA.Agent.Action.Dynamic
+{
+    public class DynamicAction : ObjectWithDynamicAttributesBase, IAction
+    {
+        public const string ATTRIBUTE_NAME = "name";
+        public DynamicAction(string name) => SetAttribute(ATTRIBUTE_NAME, name);
+        public virtual bool IsNoOperation() => false;
+        public string Name => (string)GetAttribute(ATTRIBUTE_NAME);
+        public override string DescribeType => GetType().Name;
+    }
+}

Agent/Dynamic/DynamicEnvironmentState.cs

@@ -0,0 +1,10 @@
+using AIMA.Agent.Environment;
+using AIMA.Agent.Object;
+
+namespace AIMA.Agent.Dynamic
+{
+    public class DynamicEnvironmentState : ObjectWithDynamicAttributesBase, IEnvironmentState
+    {
+        public override string DescribeType => typeof(IEnvironmentState).Name;
+    }
+}

Agent/Dynamic/DynamicPercept.cs

@@ -0,0 +1,29 @@
+using AIMA.Agent.Object;
+using AIMA.Agent.Percept;
+using System.Diagnostics;
+
+namespace AIMA.Agent.Dynamic
+{
+    public class DynamicPercept : ObjectWithDynamicAttributesBase, IPercept
+    {
+        public override string DescribeType => typeof(IPercept).Name;
+        public DynamicPercept(object key1, object value1)
+        {
+            SetAttribute(key1, value1);
+        }
+        public DynamicPercept(object key1, object value1, object key2, object value2)
+        {
+            SetAttribute(key1, value1);
+            SetAttribute(key2, value2);
+        }
+        public DynamicPercept(object[] keys, object[] values)
+        {
+            Debug.Assert(keys.Length == values.Length);
+
+            for (int i = 0; i < keys.Length; i++)
+            {
+                SetAttribute(keys[i], values[i]);
+            }
+        }
+    }
+}

Agent/Dynamic/DynamicState.cs

@@ -0,0 +1,10 @@
+using AIMA.Agent.Object;
+using AIMA.Agent.State;
+
+namespace AIMA.Agent.Dynamic
+{
+    public class DynamicState : ObjectWithDynamicAttributesBase, IState
+    {
+        public override string DescribeType => typeof(IState).Name;
+    }
+}

Agent/Environment/EnvironmentBase.cs

@@ -0,0 +1,143 @@
+using AIMA.Agent.Action;
+using AIMA.Agent.Percept;
+using System;
+using System.Collections.Generic;
+
+namespace AIMA.Agent.Environment
+{
+    public abstract class EnvironmentBase<T1, T2> : IEnvironmentViewNotifier, IEnvironment<T1, T2>
+        where T1 : IAction
+        where T2 : IPercept
+    {
+        //protected LinkedHashSet<EnvironmentObject> envObjects = new LinkedHashSet<EnvironmentObject>();
+
+        //protected LinkedHashSet<Agent> agents = new LinkedHashSet<Agent>();
+
+        //protected LinkedHashSet<EnvironmentView> views = new LinkedHashSet<EnvironmentView>();
+
+        protected Dictionary<IAgent<T1, T2>, double> _performanceMeasures { get; init; } = new();
+        public IReadOnlyDictionary<IAgent<T1, T2>, double> ReadOnlyPerformanceMeasures => _performanceMeasures;
+        public abstract IEnvironmentState GetCurrentState();
+        public abstract IEnvironmentState ExecuteAction(IAgent<T1, T2> agent, T1 action);
+        public abstract T2 GetPerceptSeenBy(IAgent<T1, T2> agent);
+        public virtual IList<IAgent<T1, T2>> GetAgents()
+        {
+            // Return as a List but also ensures the caller cannot modify
+            //return new List<IAgent<T1, T2>>(agents);
+            return null;
+        }
+
+        public virtual void AddAgent(IAgent<T1, T2> agent) => AddEnvironmentObject(agent);
+
+        public virtual void RemoveAgent(IAgent<T1, T2> agent) => RemoveEnvironmentObject(agent);
+        public virtual IList<IEnvironmentObject> GetEnvironmentObjects()
+        {
+            //// Return as a List but also ensures the caller cannot modify
+            //return new List<IEnvironmentObject>(envObjects);
+            return null;
+        }
+
+        public virtual void AddEnvironmentObject(IEnvironmentObject environmentObject)
+        {
+            //envObjects.Add(eo);
+            if (environmentObject is IAgent<T1, T2>)
+            {
+                //if (!agents.Contains(environmentObject as IAgent<T1, T2>))
+                //{
+                //    agents.Add(a);
+                //    this.updateEnvironmentViewsAgentAdded(a);
+                //}
+            }
+        }
+
+        public virtual void RemoveEnvironmentObject(IEnvironmentObject environmentObject)
+        {
+            //envObjects.Remove(eo);
+            //agents.Remove(eo);
+        }
+
+        public virtual void Step()
+        {
+            //foreach (IAgent<T1, T2> agent in agents)
+            //{
+            //    if (agent.isAlive())
+            //    {
+            //        Action anAction = agent.execute(getPerceptSeenBy(agent));
+            //        EnvironmentState es = executeAction(agent, anAction);
+            //        updateEnvironmentViewsAgentActed(agent, anAction, es);
+            //    }
+            //}
+            CreateExogenousChange();
+        }
+
+        public virtual void Step(int n)
+        {
+            for (int i = 0; i < n; i++)
+            {
+                Step();
+            }
+        }
+
+        public virtual void StepUntilDone()
+        {
+            while (!IsDone())
+            {
+                Step();
+            }
+        }
+
+        public virtual bool IsDone()
+        {
+            //foreach (Agent agent in agents)
+            //{
+            //    if (agent.isAlive())
+            //    {
+            //        return false;
+            //    }
+            //}
+            return true;
+        }
+
+        public virtual double GetPerformanceMeasure(IAgent<T1, T2> agent)
+        {
+            double? performanceMeasures = _performanceMeasures[agent];
+            if (!performanceMeasures.HasValue)
+            {
+                performanceMeasures = 0.0;
+                _performanceMeasures[agent] = performanceMeasures.Value;
+            }
+            return performanceMeasures.Value;
+        }
+
+        public virtual void AddEnvironmentView(IEnvironmentView<T1, T2> environmentView)
+        {
+            //views.Add(environmentView);
+        }
+
+        public virtual void RemoveEnvironmentView(IEnvironmentView<T1, T2> environmentView)
+        {
+            //views.Remove(ev);
+        }
+        public virtual void NotifyViews(string msg)
+        {
+            throw new NotImplementedException();
+        }
+        void CreateExogenousChange()
+        {
+
+        }
+        void UpdatePerformanceMeasure(IAgent<T1, T2> forAgent, double addTo)
+        {
+
+        }
+        void UdateEnvironmentViewsAgentAdded(IAgent<T1, T2> agent)
+        {
+
+        }
+        protected virtual void UpdateEnvironmentViewsAgentActed(IAgent<T1, T2> agent, T1 action,
+                IEnvironmentState state)
+        {
+
+        }
+    }
+}

Agent/Environment/IEnvironment.cs

@@ -0,0 +1,25 @@
+using AIMA.Agent.Action;
+using AIMA.Agent.Percept;
+using System.Collections.Generic;
+
+namespace AIMA.Agent.Environment
+{
+    public interface IEnvironment<T1,T2> where T1 : IAction where T2 : IPercept
+    {
+        IReadOnlyDictionary<IAgent<T1, T2>, double> ReadOnlyPerformanceMeasures { get; }
+        IList<IAgent<T1,T2>> GetAgents();
+        void AddAgent(IAgent<T1,T2> agent);
+        void RemoveAgent(IAgent<T1,T2> agent);
+        IList<IEnvironmentObject> GetEnvironmentObjects();
+        void AddEnvironmentObject(IEnvironmentObject environmentObject);
+        void RemoveEnvironmentObject(IEnvironmentObject environmentObject);
+        void Step();
+        void Step(int n);
+        void StepUntilDone();
+        bool IsDone();
+        double GetPerformanceMeasure(IAgent<T1,T2> agent);
+        void AddEnvironmentView(IEnvironmentView<T1,T2> environmentView);
+        void RemoveEnvironmentView(IEnvironmentView<T1,T2> environmentView);
+        void NotifyViews(string message);
+    }
+}

Agent/Environment/IEnvironmentObject.cs

@@ -0,0 +1,6 @@
+namespace AIMA.Agent.Environment
+{
+    public interface IEnvironmentObject
+    {
+    }
+}

Agent/Environment/IEnvironmentState.cs

@@ -0,0 +1,6 @@
+namespace AIMA.Agent.Environment
+{
+    public interface IEnvironmentState
+    {
+    }
+}

Agent/Environment/IEnvironmentView.cs

@@ -0,0 +1,14 @@
+using AIMA.Agent.Action;
+using AIMA.Agent.Percept;
+
+namespace AIMA.Agent.Environment
+{
+    public interface IEnvironmentView<T1,T2>
+        where T1:IAction
+        where T2: IPercept
+    {
+        void OnNotified(string message);
+        void OnAgentAdded(IAgent<T1,T2> agent, IEnvironmentState resultingState);
+        void OnAgentActed(IAgent<T1,T2> agent, T1 action, IEnvironmentState resultingState);
+    }
+}

Agent/Environment/IEnvironmentViewNotifier.cs

@@ -0,0 +1,7 @@
+namespace AIMA.Agent.Environment
+{
+    public interface IEnvironmentViewNotifier
+    {
+        void NotifyViews(string msg);
+    }
+}

Agent/IAgent.cs

@@ -0,0 +1,15 @@
+using AIMA.Agent.Action;
+using AIMA.Agent.Environment;
+using AIMA.Agent.Percept;
+
+namespace AIMA.Agent
+{
+    public interface IAgent<T1,T2> : IEnvironmentObject
+        where T1:IAction
+        where T2: IPercept
+    {
+        T1 Execute(T2 percept);
+        bool IsAlive();
+        void SetAlive(bool alive);
+    }
+}

Agent/Model/IModel.cs

@@ -0,0 +1,7 @@
+namespace AIMA.Agent.Model
+{
+    public interface IModel
+    {
+
+    }
+}

Agent/Object/IObjectWithDynamicAttributes.cs

@@ -0,0 +1,16 @@
+using System.Collections.Generic;
+
+namespace AIMA.Agent.Object
+{
+    public interface IObjectWithDynamicAttributes
+    {
+        IReadOnlyDictionary<object, object> ReadOnlyAttributes { get;}
+        string DescribeType { get; }
+        string DescribeAttributes();
+        HashSet<object> GetKeySet();
+        void SetAttribute(object key, object value);
+        object GetAttribute(object key);
+        object RemoveAttribute(object key);
+        public IObjectWithDynamicAttributes Copy();
+    }
+}

Agent/Object/ObjectWithDynamicAttributesBase.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Text;
+
+namespace AIMA.Agent.Object
+{
+    public abstract class ObjectWithDynamicAttributesBase : IObjectWithDynamicAttributes
+    {
+        private Dictionary<object, object> Attributes { get; init; } = new();
+        public IReadOnlyDictionary<object, object> ReadOnlyAttributes => Attributes;
+        public virtual string DescribeType => GetType().Name;
+        public virtual string DescribeAttributes()
+        {
+            var stringBuildr = new StringBuilder('[');
+            bool first = true;
+            foreach (object key in Attributes.Keys)
+            {
+                if (first)
+                {
+                    first = false;
+                }
+                else
+                {
+                    stringBuildr.Append(", ");
+                }
+                stringBuildr.Append(key);
+                stringBuildr.Append("==");
+                stringBuildr.Append(Attributes[key]);
+            }
+            stringBuildr.Append(']');
+            return stringBuildr.ToString();
+        }
+        public virtual HashSet<object> GetKeySet() => new(Attributes.Keys);
+        public virtual void SetAttribute(object key, object value) => Attributes[key] = value;
+        public virtual object GetAttribute(object key) => Attributes[key];
+        public virtual object RemoveAttribute(object key) => Attributes.Remove(key);
+        public virtual IObjectWithDynamicAttributes Copy()
+        {
+            ObjectWithDynamicAttributesBase copy = null;
+            try
+            {
+                copy = (ObjectWithDynamicAttributesBase)GetType().GetConstructor(Type.EmptyTypes).Invoke(null);
+                foreach (object value in Attributes)
+                {
+                    copy.Attributes.Add(value, Attributes[value]);
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.WriteLine(ex.ToString());
+            }
+            return copy;
+        }
+
+        public override bool Equals(object o)
+        {
+            if (o == null || GetType() != o.GetType())
+            {
+                return base.Equals(o);
+            }
+            return Attributes.Equals(((ObjectWithDynamicAttributesBase)o).Attributes);
+        }
+
+        public override int GetHashCode()
+        {
+            return Attributes.GetHashCode();
+        }
+
+        public override string ToString()
+        {
+            var stringBuilder = new StringBuilder();
+            stringBuilder.Append(DescribeType);
+            stringBuilder.Append(DescribeAttributes());
+            return stringBuilder.ToString();
+        }
+    }
+}

Agent/Percept/IPercept.cs

@@ -0,0 +1,6 @@
+namespace AIMA.Agent.Percept
+{
+    public interface IPercept
+    {
+    }
+}

Agent/Program/IAgentProgram.cs

@@ -0,0 +1,12 @@
+using AIMA.Agent.Action;
+using AIMA.Agent.Percept;
+
+namespace AIMA.Agent.Program
+{
+    public interface IAgentProgram<T1,T2>
+        where T1:IAction
+        where T2:IPercept
+    {
+        T1 Execute(T2 percept);
+    }
+}

Agent/Program/TableDrivenAgentProgram.cs

@@ -0,0 +1,25 @@
+using AIMA.Agent.Action;
+using AIMA.Agent.Percept;
+using System.Collections.Generic;
+
+namespace AIMA.Agent.Program
+{
+    public class TableDrivenAgentProgram<T1,T2> : IAgentProgram<T1,T2> where T1: IAction where T2:IPercept
+    {
+        private IList<T2> Percepts { get;init; } = new List<T2>();
+        //private Table<List<Percept>, System.String, Action> table;
+        private const string ACTION = "action";
+
+        public T1 Execute(T2 percept)
+        {
+            // append percept to end of percepts
+            Percepts.Add(percept);
+
+            // action <- LOOKUP(percepts, table)
+            // return action
+            //return LookupCurrentAction();
+
+            return default;
+        }
+    }
+}

Agent/State/IState.cs

@@ -0,0 +1,7 @@
+namespace AIMA.Agent.State
+{
+    public interface IState
+    {
+
+    }
+}

Agent/Table/IRow.cs

@@ -0,0 +1,15 @@
+using System.Collections.Generic;
+
+namespace AIMA.Agent.Table
+{
+    public interface IRow<ColumnHeaderType, ValueType> where ValueType:struct
+    {
+        Dictionary<ColumnHeaderType, ValueType> Columns { get; init; }
+
+        public Dictionary<ColumnHeaderType, ValueType> Cells()
+        {
+            return Columns;
+        }
+
+    }
+}

Agent/Table/ITable.cs

@@ -0,0 +1,13 @@
+using System.Collections.Generic;
+
+namespace AIMA.Agent.Table
+{
+    public interface ITable<RowHeaderType, ColumnHeaderType, ValueType> where ValueType : struct
+    {
+        List<RowHeaderType> RowHeaders { get; init; }
+        List<ColumnHeaderType> ColumnHeaders { get; init; }
+        Dictionary<RowHeaderType, Dictionary<ColumnHeaderType, ValueType>> Rows { get; init; }
+        void Set(RowHeaderType r, ColumnHeaderType c, ValueType v);
+        ValueType Get(RowHeaderType r, ColumnHeaderType c);
+    }
+}

Agent/Table/TableBase.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace AIMA.Agent.Table
+{
+    public abstract record TableBase<RowHeaderType, ColumnHeaderType, ValueType>(List<RowHeaderType> RowHeaders,
+        List<ColumnHeaderType> ColumnHeaders, Dictionary<RowHeaderType, Dictionary<ColumnHeaderType, ValueType>> Rows)
+        : ITable<RowHeaderType, ColumnHeaderType, ValueType> where ValueType : struct
+    {
+
+        public virtual ValueType Get(RowHeaderType r, ColumnHeaderType c)
+        {
+            return default;
+        }
+        public virtual void Set(RowHeaderType r, ColumnHeaderType c, ValueType v)
+        { 
+        }
+    }
+}

Program.cs

@@ -0,0 +1,3 @@
+using System;
+
+Console.WriteLine("Hello World!");

Utility/LinkedHashSet.cs

@@ -0,0 +1,119 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace AIMA.Utility
+{
+    public class LinkedHashSet<T> : ISet<T>
+    {
+        private readonly IDictionary<T, LinkedListNode<T>> _keyValuePairs;
+        private readonly LinkedList<T> _linkList;
+        public LinkedHashSet(int initialCapacity)
+        {
+            _keyValuePairs = new Dictionary<T, LinkedListNode<T>>(initialCapacity);
+            _linkList = new LinkedList<T>();
+        }
+
+        public LinkedHashSet()
+        {
+            _keyValuePairs = new Dictionary<T, LinkedListNode<T>>();
+            _linkList = new LinkedList<T>();
+        }
+        public int Count => throw new NotImplementedException();
+
+        public bool IsReadOnly => throw new NotImplementedException();
+
+        public bool Add(T item)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void Clear()
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Contains(T item)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void CopyTo(T[] array, int arrayIndex)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void ExceptWith(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public IEnumerator<T> GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+
+        public void IntersectWith(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsProperSubsetOf(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsProperSupersetOf(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsSubsetOf(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool IsSupersetOf(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Overlaps(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool Remove(T item)
+        {
+            throw new NotImplementedException();
+        }
+
+        public bool SetEquals(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void SymmetricExceptWith(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        public void UnionWith(IEnumerable<T> other)
+        {
+            throw new NotImplementedException();
+        }
+
+        void ICollection<T>.Add(T item)
+        {
+            throw new NotImplementedException();
+        }
+
+        IEnumerator IEnumerable.GetEnumerator()
+        {
+            throw new NotImplementedException();
+        }
+    }
+}