public override void Execute(Interpreter inI)
{
IntStack istack = inI.IntStack();
ObjectStack estack = inI.ExecStack();
if (_stack.Size() > 0 && istack.Size() > 0)
{
if (istack.Top() > 0)
{
int stop = istack.Pop() - 1;
object bodyObj = _stack.Pop();
try
{
Program doRangeMacroProgram = new Program();
doRangeMacroProgram.Push(0);
doRangeMacroProgram.Push(stop);
doRangeMacroProgram.Push("exec.do*range");
doRangeMacroProgram.Push(bodyObj);
estack.Push(doRangeMacroProgram);
}
catch (Exception)
{
Console.Error.WriteLine("Error while initializing a program.");
}
}
}
}
/// <summary>
/// Reflect all atoms (indexes) int he provided stack around the line formed
/// of the beg and end atoms.
/// </summary>
/// <param name="stack">atom indexes to reflect</param>
/// <param name="beg">beg atom of a bond</param>
/// <param name="end">end atom of a bond</param>
private void Reflect(IntStack stack, IAtom beg, IAtom end)
{
var begP = beg.Point2D.Value;
var endP = end.Point2D.Value;
Reflect(stack, begP, endP);
}
// Begin exec iteration functions
public override void Execute(Interpreter inI)
{
IntStack istack = inI.IntStack();
ObjectStack estack = inI.ExecStack();
if (_stack.Size() > 0 && istack.Size() > 1)
{
int stop = istack.Pop();
int start = istack.Pop();
object code = _stack.Pop();
if (start == stop)
{
istack.Push(start);
estack.Push(code);
}
else
{
istack.Push(start);
start = (start < stop) ? (start + 1) : (start - 1);
// trh//Made changes to correct errors with code.do*range
try {
Program recursiveCallProgram = new Program();
recursiveCallProgram.Push(start);
recursiveCallProgram.Push(stop);
recursiveCallProgram.Push("exec.do*range");
recursiveCallProgram.Push(code);
estack.Push(recursiveCallProgram);
} catch (Exception) {
Console.Error.WriteLine("Error while initializing a program.");
}
estack.Push(code);
}
}
}
/// <summary>
/// Restore the coordinates of atoms (indexes) in the stack to the provided
/// source.
/// </summary>
/// <param name="stack">atom indexes to backup</param>
/// <param name="src">source of coordinates</param>
private void RestoreCoords(IntStack stack, Vector2[] src)
{
for (int i = 0; i < stack.len; i++)
{
var v = stack.xs[i];
atoms[v].Point2D = new Vector2(src[v].X, src[v].Y);
}
}
/// <summary>
/// Backup the coordinates of atoms (indexes) in the stack to the provided
/// destination.
/// </summary>
/// <param name="dest">destination</param>
/// <param name="stack">atom indexes to backup</param>
private void BackupCoords(Vector2[] dest, IntStack stack)
{
for (int i = 0; i < stack.len; i++)
{
var v = stack.xs[i];
dest[v] = new Vector2(atoms[v].Point2D.Value.X, atoms[v].Point2D.Value.Y);
}
}
public void Test1()
{
IntStack x = new IntStack(3);
x.Push(1);
x.Push(2);
Assert.Equal(false, x.IsEmpty());
Assert.Equal(2, x.Pop());
}
public override void Execute(Interpreter inI)
{
ObjectStack codeStack = inI.CodeStack();
IntStack iStack = inI.IntStack();
if (iStack.Size() > 0)
{
codeStack.Push(iStack.Pop());
}
}
protected void setUp()
{
interpreter = new Interpreter();
Program instructionList = new Program("( )");
interpreter.randProgram.SetInstructions(interpreter, instructionList);
istack = new IntStack();
fstack = new FloatStack();
bstack = new BooleanStack();
}
private void Reflect(IntStack stack, Vector2 begP, Vector2 endP)
{
double dx = endP.X - begP.X;
double dy = endP.Y - begP.Y;
double a = (dx * dx - dy * dy) / (dx * dx + dy * dy);
double b = 2 * dx * dy / (dx * dx + dy * dy);
for (int i = 0; i < stack.len; i++)
{
Reflect(atoms[stack.xs[i]], begP, a, b);
}
}
public override void Execute(Interpreter inI)
{
IntStack iStack = inI.IntStack();
if (iStack.Size() > 0)
{
int index = iStack.Pop();
if (_stack.Size() > 0)
{
_stack.YankDup(index);
}
else
{
iStack.Push(index);
}
}
}
/// <summary>
/// Create a new layout refiner for the provided molecule.
/// </summary>
/// <param name="mol">molecule to refine</param>
internal LayoutRefiner(IAtomContainer mol, ISet <IAtom> afix, ISet <IBond> bfix)
{
this.mol = mol;
this.afix = afix;
this.bfix = bfix;
this.bondMap = EdgeToBondMap.WithSpaceFor(mol);
this.adjList = GraphUtil.ToAdjList(mol, bondMap);
this.idxs = new Dictionary <IAtom, int>();
foreach (var atom in mol.Atoms)
{
idxs[atom] = idxs.Count;
}
this.atoms = mol.Atoms.ToArray();
// buffers for storing coordinates
this.buffer1 = new Vector2[atoms.Length];
this.buffer2 = new Vector2[atoms.Length];
this.backup = new Vector2[atoms.Length];
for (int i = 0; i < buffer1.Length; i++)
{
buffer1[i] = new Vector2();
buffer2[i] = new Vector2();
backup[i] = new Vector2();
}
this.stackBackup = new IntStack(atoms.Length);
this.visited = new bool[atoms.Length];
this.congestion = new Congestion(mol, adjList);
// note, this is lazy so only does the shortest path when needed
// and does |V| search at maximum
this.apsp = new AllPairsShortestPaths(mol);
// index ring systems, idx -> ring system number (rnum)
int rnum = 1;
this.ringsystems = new int[atoms.Length];
for (int i = 0; i < atoms.Length; i++)
{
if (atoms[i].IsInRing && ringsystems[i] == 0)
{
TraverseRing(ringsystems, i, rnum++);
}
}
}
static void Main(string[] args)
{
// create a new IntStack
IntStack stack = new IntStack();
stack.Push(2);
stack.Push(4);
stack.Push(8);
for (int i = 0; i < 3; i++)
{
Console.WriteLine("Pop value: {0}", stack.Pop());
}
// wait for input before exiting
Console.WriteLine("Press enter to finish");
Console.ReadLine();
}
public override void Execute(Interpreter inI)
{
IntStack istack = inI.IntStack();
if (istack.Size() > 0 && _stack.Size() > 0)
{
int index = istack.Pop();
if (index < 0)
{
index = 0;
}
if (index >= _stack.Size())
{
index = _stack.Size() - 1;
}
inI.GetInputPusher().PushInput(inI, index);
}
}
public override void Execute(Interpreter inI)
{
IntStack istack = inI.IntStack();
ObjectStack estack = inI.ExecStack();
if (_stack.Size() > 0 && istack.Size() > 0)
{
if (istack.Top() > 0)
{
object bodyObj = _stack.Pop();
if (bodyObj is Program)
{
// insert integer.pop in front of program
((Program)bodyObj).Shove("integer.pop", ((Program)bodyObj)._size);
}
else
{
// create a new program with integer.pop in front of
// the popped object
Program newProgram = new Program();
newProgram.Push("integer.pop");
newProgram.Push(bodyObj);
bodyObj = newProgram;
}
int stop = istack.Pop() - 1;
try
{
Program doRangeMacroProgram = new Program();
doRangeMacroProgram.Push(0);
doRangeMacroProgram.Push(stop);
doRangeMacroProgram.Push("code.quote");
doRangeMacroProgram.Push(bodyObj);
doRangeMacroProgram.Push("code.do*range");
estack.Push(doRangeMacroProgram);
}
catch (Exception)
{
Console.Error.WriteLine("Error while initializing a program.");
}
}
}
}
/// <summary>
/// Resolves conflicts either by bending bonds or stretching bonds in the
/// shortest path between an overlapping pair. Bending and stretch are tried
/// for each pair and the best resolution is used.
/// </summary>
/// <param name="pairs">pairs</param>
private void BendOrStretch(IEnumerable <AtomPair> pairs)
{
// without checking which bonds have been bent/stretch already we
// could end up repeating a lot of repeated work to no avail
var bendVisit = new Dictionary <IBond, AtomPair>();
var stretchVisit = new Dictionary <IBond, AtomPair>();
var bendStack = new IntStack(atoms.Length);
var stretchStack = new IntStack(atoms.Length);
foreach (var pair in pairs)
{
double score = congestion.Score();
// each attempt will be more aggressive/distorting
for (pair.attempt = 1; pair.attempt <= 3; pair.attempt++)
{
bendStack.Clear();
stretchStack.Clear();
// attempt both bending and stretching storing the
// best result in the provided buffer
var bendScore = Bend(pair, bendStack, buffer1, bendVisit);
var stretchScore = Stretch(pair, stretchStack, buffer2, stretchVisit);
// bending is better than stretching
if (bendScore < stretchScore && bendScore < score)
{
RestoreCoords(bendStack, buffer1);
congestion.Update(bendStack.xs, bendStack.len);
break;
}
// stretching is better than bending
else if (bendScore > stretchScore && stretchScore < score)
{
RestoreCoords(stretchStack, buffer2);
congestion.Update(stretchStack.xs, stretchStack.len);
break;
}
}
}
}
public override float EvaluateTestCase(GAIndividual inIndividual, object inInput, object inOutput)
{
_interpreter.ClearStacks();
int currentInput = (int)inInput;
IntStack stack = _interpreter.IntStack();
stack.Push(currentInput);
// Must be included in order to use the input stack.
_interpreter.InputStack().Push(currentInput);
_interpreter.Execute(((PushGPIndividual)inIndividual)._program, _executionLimit);
int result = stack.Top();
// System.out.println( _interpreter + " " + result );
// Penalize individual if there is no result on the stack.
if (stack.Size() == 0)
{
return(_noResultPenalty);
}
return(result - ((int)inOutput));
}
public void PushInput(Interpreter inI, int n)
{
ObjectStack _stack = inI.InputStack();
if (_stack.Size() > n)
{
object inObject = _stack.DeepPeek(n);
if (inObject is int)
{
IntStack istack = inI.IntStack();
istack.Push((int)inObject);
}
else
{
// if (inObject is Number)
// {
// FloatStack fstack = inI.FloatStack();
// fstack.Push(((Number)inObject).FloatValue());
// }
//else
if (inObject is float)
{
FloatStack fstack = inI.FloatStack();
fstack.Push((float)inObject);
}
else
{
if (inObject is bool)
{
BooleanStack bstack = inI.BoolStack();
bstack.Push((bool)inObject);
}
else
{
Console.Error.WriteLine("Error during input.index - object " + inObject.GetType() +
" is not a legal object according to " + this.GetType() + ".");
}
}
}
}
}
/// <summary>
/// Stretch the distance between beg and end, moving all atoms provided in
/// the stack.
/// </summary>
/// <param name="stack">atoms to be moved</param>
/// <param name="beg">begin atom of a bond</param>
/// <param name="end">end atom of a bond</param>
/// <param name="amount">amount to try stretching by (absolute)</param>
private void Stretch(IntStack stack, IAtom beg, IAtom end, double amount)
{
var begPoint = beg.Point2D.Value;
var endPoint = end.Point2D.Value;
if (Vector2.Distance(begPoint, endPoint) + amount > MaxBondLength)
{
return;
}
var vector = new Vector2(endPoint.X - begPoint.X, endPoint.Y - begPoint.Y);
vector = Vector2.Normalize(vector);
vector *= amount;
for (int i = 0; i < stack.len; i++)
{
var atom = atoms[stack.xs[i]];
atom.Point2D = atom.Point2D.Value + vector;
}
}
static void Main(string[] args)
{
// create an instance from the derived type
IntStack intStack = new IntStack();
// upcast to the base type
GenericStack <int> gStack = intStack;
// push some data into the stack
intStack.Push(1);
intStack.Push(2);
intStack.Push(3);
// pop the data back out of the stack
for (int i = 0; i < 3; i++)
{
Console.WriteLine("Popped Value: {0}", intStack.Pop());
}
// wait for input before exiting
Console.WriteLine("Press enter to finish");
Console.ReadLine();
}
public override void Execute(Interpreter inI)
{
IntStack stack = inI.IntStack();
stack.Push(_stack.Size());
}
/// <summary>
/// Stretch all bonds in the shortest path between a pair of atoms in an
/// attempt to resolve the overlap. The stretch that produces the minimum
/// congestion is stored in the provided stack and coordinates with the congestion
/// score returned.
/// </summary>
/// <param name="pair">congested atom pair</param>
/// <param name="stack">best result vertices</param>
/// <param name="coords">best result coordinates</param>
/// <param name="firstVisit">visit map to avoid repeating work</param>
/// <returns>congestion score of best result</returns>
private double Stretch(AtomPair pair, IntStack stack, Vector2[] coords, Dictionary <IBond, AtomPair> firstVisit)
{
stackBackup.Clear();
var score = congestion.Score();
var min = score;
foreach (var bond in pair.bndAt)
{
// don't stretch ring bonds
if (bond.IsInRing)
{
continue;
}
if (bfix.Contains(bond))
{
continue;
}
// has this bond already been tested as part of another pair
if (!firstVisit.TryGetValue(bond, out AtomPair first))
{
firstVisit[bond] = first = pair;
}
if (first != pair)
{
continue;
}
var beg = bond.Begin;
var end = bond.End;
var begIdx = idxs[beg];
var endIdx = idxs[end];
var begPriority = beg.GetProperty <int>(AtomPlacer.Priority);
var endPriority = end.GetProperty <int>(AtomPlacer.Priority);
Arrays.Fill(visited, false);
if (begPriority < endPriority)
{
stack.len = Visit(visited, stack.xs, endIdx, begIdx, 0);
}
else
{
stack.len = Visit(visited, stack.xs, begIdx, endIdx, 0);
}
BackupCoords(backup, stack);
if (begPriority < endPriority)
{
Stretch(stack, end, beg, pair.attempt * StrechStep);
}
else
{
Stretch(stack, beg, end, pair.attempt * StrechStep);
}
congestion.Update(visited, stack.xs, stack.len);
if (PercDiff(score, congestion.Score()) >= ImprovementPrecThreshold && congestion.Score() < min)
{
BackupCoords(coords, stack);
min = congestion.Score();
stackBackup.CopyFrom(stack);
}
RestoreCoords(stack, backup);
congestion.Update(visited, stack.xs, stack.len);
congestion.score = score;
}
stack.CopyFrom(stackBackup);
return(min);
}
/// <summary>
/// Bend all bonds in the shortest path between a pair of atoms in an attempt
/// to resolve the overlap. The bend that produces the minimum congestion is
/// stored in the provided stack and coords with the congestion score
/// returned.
/// </summary>
/// <param name="pair">congested atom pair</param>
/// <param name="stack">best result vertices</param>
/// <param name="coords">best result coords</param>
/// <param name="firstVisit">visit map to avoid repeating work</param>
/// <returns>congestion score of best result</returns>
private double Bend(AtomPair pair, IntStack stack, Vector2[] coords, Dictionary <IBond, AtomPair> firstVisit)
{
stackBackup.Clear();
Trace.Assert(stack.len == 0);
double score = congestion.Score();
double min = score;
// special case: if we have an even length path where the two
// most central bonds are cyclic but the next two aren't we bend away
// from each other
if (pair.bndAt.Count > 4 && (pair.bndAtCode & 0x1F) == 0x6)
{
var bndA = pair.bndAt[2];
var bndB = pair.bndAt[3];
if (bfix.Contains(bndA) || bfix.Contains(bndB))
{
return(int.MaxValue);
}
var pivotA = GetCommon(bndA, pair.bndAt[1]);
var pivotB = GetCommon(bndB, pair.bndAt[0]);
if (pivotA == null || pivotB == null)
{
return(int.MaxValue);
}
Arrays.Fill(visited, false);
int split = Visit(visited, stack.xs, idxs[pivotA], idxs[bndA.GetOther(pivotA)], 0);
stack.len = Visit(visited, stack.xs, idxs[pivotB], idxs[bndB.GetOther(pivotB)], split);
// perform bend one way
BackupCoords(backup, stack);
Bend(stack.xs, 0, split, pivotA, BendStep);
Bend(stack.xs, split, stack.len, pivotB, -BendStep);
congestion.Update(stack.xs, stack.len);
if (PercDiff(score, congestion.Score()) >= ImprovementPrecThreshold)
{
BackupCoords(coords, stack);
stackBackup.CopyFrom(stack);
min = congestion.Score();
}
// now bend the other way
RestoreCoords(stack, backup);
Bend(stack.xs, 0, split, pivotA, -BendStep);
Bend(stack.xs, split, stack.len, pivotB, BendStep);
congestion.Update(stack.xs, stack.len);
if (PercDiff(score, congestion.Score()) >= ImprovementPrecThreshold && congestion.Score() < min)
{
BackupCoords(coords, stack);
stackBackup.CopyFrom(stack);
min = congestion.Score();
}
// restore original coordinates and reset score
RestoreCoords(stack, backup);
congestion.Update(stack.xs, stack.len);
congestion.score = score;
}
// general case: try bending acyclic bonds in the shortest
// path from inside out
else
{
// try bending all bonds and accept the best one
foreach (var bond in pair.bndAt)
{
if (bond.IsInRing)
{
continue;
}
if (bfix.Contains(bond))
{
continue;
}
// has this bond already been tested as part of another pair
if (!firstVisit.TryGetValue(bond, out AtomPair first))
{
firstVisit[bond] = first = pair;
}
if (first != pair)
{
continue;
}
var beg = bond.Begin;
var end = bond.End;
var begPriority = beg.GetProperty <int>(AtomPlacer.Priority);
var endPriority = end.GetProperty <int>(AtomPlacer.Priority);
Arrays.Fill(visited, false);
if (begPriority < endPriority)
{
stack.len = Visit(visited, stack.xs, idxs[beg], idxs[end], 0);
}
else
{
stack.len = Visit(visited, stack.xs, idxs[end], idxs[beg], 0);
}
BackupCoords(backup, stack);
// bend one way
if (begPriority < endPriority)
{
Bend(stack.xs, 0, stack.len, beg, pair.attempt * BendStep);
}
else
{
Bend(stack.xs, 0, stack.len, end, pair.attempt * BendStep);
}
congestion.Update(visited, stack.xs, stack.len);
if (PercDiff(score, congestion.Score()) >= ImprovementPrecThreshold &&
congestion.Score() < min)
{
BackupCoords(coords, stack);
stackBackup.CopyFrom(stack);
min = congestion.Score();
}
// bend other way
if (begPriority < endPriority)
{
Bend(stack.xs, 0, stack.len, beg, pair.attempt * -BendStep);
}
else
{
Bend(stack.xs, 0, stack.len, end, pair.attempt * -BendStep);
}
congestion.Update(visited, stack.xs, stack.len);
if (PercDiff(score, congestion.Score()) >= ImprovementPrecThreshold && congestion.Score() < min)
{
BackupCoords(coords, stack);
stackBackup.CopyFrom(stack);
min = congestion.Score();
}
RestoreCoords(stack, backup);
congestion.Update(visited, stack.xs, stack.len);
congestion.score = score;
}
}
stack.CopyFrom(stackBackup);
return(min);
}
public void CopyFrom(IntStack stack)
{
Array.Copy(stack.xs, 0, xs, 0, stack.len);
this.len = stack.len;
}
public BehaviourIterator(BehaviourTree tree, int levelOffset)
{
_tree = tree;
_traversal = new IntStack(_tree.Height);
_levelOffset = levelOffset;
}
