public void Initialize(int memSize)
{
MemorySize = memSize;
for (int i = 0; i < MemorySize; i++)
{
Memory.Add(new MemoryBlock()
{
ProcessId = 0,
IsAssigned = false,
IsEnd = false,
IsStart = false
});
}
MemoryInitEventArgs arg = new MemoryInitEventArgs
{
MemoryAlgorithmName = "Best Fit",
NumberOfBlocks = MemorySize,
Memory = this.Memory
};
BlockFit firstblock = new BlockFit();
firstblock.start_pos = 0;
firstblock.ID = 0;
firstblock.blockLength = MemorySize;
avail.Add(firstblock);
OnInitialize(arg);
}
public override string Part1(string input)
{
var lines = input.Lines();
var mask = new Mask("XXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXXX");
var memory = new Memory();
foreach (var line in lines)
{
var parts = line.Split();
if (line.StartsWith("mask"))
{
mask = new Mask(parts[2]);
}
else if (line.StartsWith("mem"))
{
var lhs = parts[0].Split('[', ']');
var address = int.Parse(lhs[1]);
var value = int.Parse(parts[2]);
var maskedValue = mask.Apply(value);
memory.Add(address, maskedValue);
}
}
return(memory.Sum().ToString());
}
private void ExtendMemory(int goal)
{
for (int k = Memory.Count + 1; k <= goal + 1; k++)
{
Memory.Add(0);
}
}
public void Part1Initialise()
{
if (Memory != null)
{
Memory.Clear();
}
foreach (ICommand command in InitProgram)
{
if (command is BitMask)
{
var bitMaskCommand = command as BitMask;
CurrentBitMask = bitMaskCommand.BinaryStringValue;
}
if (command is MemoryCommand)
{
var memoryCommand = command as MemoryCommand;
int address = memoryCommand.Address;
string maskifiedBinaryString = MaskifyValue(memoryCommand.BinaryStringValue);
double value = IntifyBinaryStringValue(maskifiedBinaryString);
if (Memory.ContainsKey(address))
{
Memory[address] = value;
}
else
{
Memory.Add(memoryCommand.Address, value);
}
}
}
}
/// <summary>
/// Checks to see if we have a memory of the new target
/// If we do not, then we create one
/// </summary>
/// <param name="target">The Object the AI is seeking</param>
private void MakeNewMemory(GameObject target)
{
if (!myMemory.ContainsKey(target))
{
targets.Add(target);
myMemory.Add(target, new MemoryProps());
}
}
public Task3_FindTorrents(MyNamedTasks Tasks)
: base(Tasks, "Task3_FindTorrents")
{
var NamedTasks = Tasks;
this.Description = @"
This task will fetch torrent links and spawn work for them.
This could be extended to support multiple torrent services.
Default implmentation will assume <a href='http://piratebay.org/'>piratebay</a>.
This task should not run when there is work for Task4_PrepareMedia
" ;
this.YieldWork =
(Task, Input) =>
{
// if we fail, we this work item will not be retried
Input.Delete();
var DismissedItems = 0;
BasicPirateBaySearch.Search(
k => Memory.Contains(k.Hash),
(entry, deferred) =>
{
if (deferred)
{
DismissedItems++;
return;
}
Memory.Add(entry.Hash);
AppendLog("output " + entry.Name);
var c = NamedTasks.Task4_PrepareMedia.AddWork(5, entry.Hash).ToFieldBuilder();
FileMappedField
TorrentName = c[entry.Name],
TorrentLink = c[entry.TorrentLink],
TorrentSize = c[entry.Size],
TorrentComments = c[entry.Link];
c.ToFile();
}
);
if (DismissedItems > 0)
{
AppendLog("dismissed " + DismissedItems);
}
return(delegate
{
// this will be called if the task is still active
});
};
}
// Ben Thornhill
public void InitializeMemory()
{
Memory.Clear();
for (int i = 0; i < MemorySize; i++)
{
Memory.Add("0000");
}
}
static void tryAddToMemory(Collectable item)
{
try {
shortTermMemory.Add(item.ID, new ObjectState());
}
catch (System.ArgumentException) {
Debug.LogError("A chave [ " + item.ID + " ] para ' " + item.name + " ' já existe no dicionario");
}
}
public long ReadMemory(int address)
{
if (!Memory.ContainsKey(address))
{
Memory.Add(address, 0);
}
return(Memory[address]);
}
public override string AddClass(ClassDetails classDetails, string parentHash)
{
Class @class = new(classDetails.Modifier, classDetails.Name, new ModelProperties(classDetails.IsModel, classDetails.ModelLocation), parentHash);
@class.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(@class))));
Memory.Add(@class);
return(@class.Hash);
}
protected override void OnTextChanged(EventArgs e)
{
saved = false;
base.OnTextChanged(e);
//CurrentText = Text;
MakeAutoCompletion(true);
CheckWords();
Memory.Add(Text);
//autoCompletion.Focus();
}
internal void UpdateMemorySize(ulong size)
{
// Geth's approach to memory trace is to show empty memory spaces on entry for the values that are being set by the operation
int missingChunks = (int)((size - (ulong)Memory.Count * EvmPooledMemory.WordSize) / EvmPooledMemory.WordSize);
for (int i = 0; i < missingChunks; i++)
{
Memory.Add("0000000000000000000000000000000000000000000000000000000000000000");
}
}
public Sample AddSample(Sample sample)
{
Memory.Add(sample);
if (Memory.Count > MemoryCapacity - 1)
{
Memory.RemoveAt(0);
}
TuneFilter();
return(Filter.AddSample(sample));
}
public Life(List <Life> world, double X, double Y, List <LayerConfig> newgen = null, Life parent = null)
{
x = X;
y = Y;
pL = pR = pB = pT = 0.0;
sL = sR = sB = sT = 0.0;
network.AddLayer(new BasicLayer(null, true, 4)); //создание простой многослойной нейронной сети
if (newgen == null)
{
int maxlayers = 3 + rnd.Next(15);
for (int i = 0; i < maxlayers; i++)
{
bool bias = rnd.NextDouble() >= 0.5;
var layer = new LayerConfig((byte)rnd.Next(0, 16), bias, rnd.Next(100) + 10);
genotype.Add(layer);
}
}
else
{
genotype = Mutate(newgen);
}
AddLayers(genotype);
if (parent != null)
{
for (int i = 0; i < parent.Memory.Count; i++)
{
if (rnd.NextDouble() > 0.5)
{
Memory.Add(parent.Memory[i]);
MemorySense.Add(parent.MemorySense[i]);
}
}
}
//network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationSoftMax(), false, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationSoftMax (), true, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationSoftMax(), false, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationSoftMax(), true, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationStep (), false, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationStep(), true, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationStep(), false, rnd.Next(100) + 10));
//network.AddLayer(new BasicLayer(new ActivationSigmoid(), true, rnd.Next(100) + 10));
network.AddLayer(new BasicLayer(new ActivationSigmoid(), false, 4));
network.Structure.FinalizeStructure();
network.Reset();
World = world;
}
public override string AddField(FieldDetails fieldDetails, string parentHash)
{
var type = fieldDetails.Type;
TypeMapper(ref type);
Field field = new(fieldDetails.Modifier, type, fieldDetails.Name, parentHash);
field.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(field))));
Memory.Add(field);
return(field.Hash);
}
private void UpdateMemory(string n)
{
ulong address = ulong.Parse(Regex.Matches(n, @"\[\d+\]").First().ToString().Replace("[", "").Replace("]", ""));
if (Memory.ContainsKey(address))
{
Memory[address] = ApplyMask(n.Split("=").ElementAt(1).Trim());
}
else
{
Memory.Add(address, ApplyMask(n.Split("=").ElementAt(1).Trim()));
}
}
public override string AddField(FieldDetails fieldDetails, string parentHash)
{
var type = fieldDetails.Type;
TypeMapper(ref type);
Property property = new(type, fieldDetails.Name, parentHash);
property.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(property))));
Memory.Add(property);
return(property.Hash);
}
public override string AddExpression(ExpressionDetails expressionDetails, string parentHash, List <string> modelTypes = null)
{
var statement = expressionDetails.Statement;
StringMapper(ref statement);
Expression expression = new(statement, parentHash);
expression.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(expression))));
Memory.Add(expression);
return(expression.Hash);
}
public override string AddMethod(MethodDetails methodDetails, string parentHash)
{
var parameters = methodDetails.Parameters;
StringMapper(ref parameters);
Function function = new(methodDetails.Identifier, methodDetails.Modifier, string.Empty, parameters, methodDetails.ReturnType, parentHash);
function.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(function))));
Memory.Add(function);
return(function.Hash);
}
public CellProcessorBase(Memory memory, CellOperators operators) : base(memory)
{
TestStatus = new TestStatus();
CallStack = new CallStack();
this.operators = operators;
operators.Processor = this;
Memory.GetItem <Symbols>();
Memory.GetItem <Procedures>();
Memory.Add(new FitEnvironment(this));
Memory.ItemOf <FitEnvironment>().RunTest = new RunTestDefault();
ApplicationUnderTest.AddNamespace("fitSharp.Fit.Fixtures");
}
/// <summary>
/// Rewards the agent for perfomic an action
/// ,memorizes and learns from the experience
/// </summary>
/// <param name="reward">-+</param>
public void Learn(double reward)
{
// perform an update on Q function
if (this.r0 > 0 && Options.Alpha > 0)
{
// learn from this tuple to get a sense of how "surprising" it is to the agent
var exp = new Experience
{
PreviousState = s0,
PreviousAction = a0,
PreviousReward = r0,
CurrentState = s1,
CurrentAction = a1
};
var tderror = LearnFromExperience(exp);
TDError = tderror; // a measure of surprise
// decide if we should keep this experience in the replay
if (t % Options.ExperinceAddEvery == 0)
{
Memory.Add(new Experience {
PreviousState = s0, PreviousAction = a0, PreviousReward = r0, CurrentState = s1, CurrentAction = a1
});
if (Options.ExperienceSize > 0 && Memory.Count > Options.ExperienceSize)
{
//forget oldest
Memory.RemoveAt(0);
}
}
this.t += 1;
// sample some additional experience from replay memory and learn from it
if (Options.AdaptiveLearningSteps)
{
var op = Memory.Count * 0.005;
if (op > 0)
{
Options.LearningSteps = op.ToInt();
}
}
for (var k = 0; k < Options.LearningSteps; k++)
{
var ri = Tembo.RandomInt(0, Memory.Count); // todo: priority sweeps?
var e = Memory[ri];
LearnFromExperience(e);
}
}
this.r0 = reward; // store for next update
}
/// <summary>
/// Adds an element by key, and returns whether or not the key was new.
/// </summary>
internal bool Add(TKey key, TElement element)
{
Memory <TElement> elements;
if (!dict.TryGetValue(key, out elements))
{
elements = new Memory <TElement>();
dict[key] = elements;
elements.Add(element);
return(true);
}
else
{
elements.Add(element);
return(false);
}
}
public override string AddMethod(MethodDetails methodDetails, string parentHash)
{
var parameters = methodDetails.Parameters;
StringMapper(ref parameters);
var parameterAnchor = methodDetails.ParameterAnchor;
StringMapper(ref parameterAnchor);
Method method = new(methodDetails.Modifier, methodDetails.ReturnType, methodDetails.Identifier, parameters, parameterAnchor, parentHash);
method.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(method))));
Memory.Add(method);
return(method.Hash);
}
public override string AddConstructor(ConstructorDetails constructorDetails, string parentHash)
{
var parameters = constructorDetails.Parameters;
StringMapper(ref parameters);
var parameterAnchor = constructorDetails.ParameterAnchor;
StringMapper(ref parameterAnchor);
Constructor constructor = new(constructorDetails.Modifier, constructorDetails.Identifier, parameters, parameterAnchor, parentHash);
constructor.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(constructor))));
Memory.Add(constructor);
return(constructor.Hash);
}
private void UpdateMemoryNew(string n)
{
long address = long.Parse(Regex.Matches(n, @"\[\d+\]").First().ToString().Replace("[", "").Replace("]", ""));
ulong[] allAddresses = GetAddresses(address);
foreach (var a in allAddresses)
{
if (Memory.ContainsKey(a))
{
Memory[a] = Convert.ToUInt64(n.Split("=").ElementAt(1).Trim());
}
else
{
Memory.Add(a, Convert.ToUInt64(n.Split("=").ElementAt(1).Trim()));
}
}
}
public override void Push(Experience trans)
{
if (trans == null)
{
throw new ArgumentNullException();
}
if (Memory.Count < Capacity)
{
Memory.Add(trans);
}
else
{
Memory[NextIndex] = trans;
}
NextIndex = (NextIndex + 1) % Capacity;
}
public override string AddExpression(ExpressionDetails expressionDetails, string parentHash, List <string> modelTypes = null)
{
if (expressionDetails.SyntaxKind == SyntaxKind.LocalDeclarationStatement)
{
expressionDetails.Statement = expressionDetails.Statement.Split(" ", 2).Select((content, count) => count == 0 ? content.CheckRequiresMemorySyntax(modelTypes) : content).Aggregate((i, j) => i + " " + j);
}
var statement = expressionDetails.Statement;
StringMapper(ref statement);
Expression expression = new(statement, parentHash);
expression.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(expression))));
Memory.Add(expression);
return(expression.Hash);
}
public override string AddClass(ClassDetails classDetails, string parentHash)
{
if (classDetails.IsModel)
{
Struct @struct = new(classDetails.Name, new ModelProperties(classDetails.IsModel, classDetails.ModelLocation), parentHash);
@struct.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(@struct))));
Memory.Add(@struct);
return(@struct.Hash);
}
else
{
Contract contract = new(classDetails.Name, parentHash);
contract.Hash = Tools.ByteToHex(Tools.GetSha256Hash(Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(contract))));
Memory.Add(contract);
return(contract.Hash);
}
}
//
// Methods
//
internal Memory Clone()
{
Memory image = new Memory()
{
Orbs = this.Orbs,
Playtime = this.Playtime,
Health = this.Health,
AnimatorController = this.AnimatorController,
HasGun = this.HasGun,
HasHook = this.HasHook,
Checkpoint = this.Checkpoint,
};
foreach (var item in this)
{
image.Add(
item.Key,
new ObjectState(item.Value));
}
return(image);
}
public void Initialize(int memSize)
{
MemorySize = memSize;
for (int i = 0; i < MemorySize; i++)
{
Memory.Add(new MemoryBlock()
{
ProcessId = 0,
IsAssigned = false,
IsEnd = false,
IsStart = false
});
}
MemoryInitEventArgs arg = new MemoryInitEventArgs
{
MemoryAlgorithmName = "First Fit",
NumberOfBlocks = MemorySize,
Memory = this.Memory
};
OnInitialize(arg);
}