public static Path <SS, DS> ExtractPath(DS Sstart, DS SPgoal,
ExtendedDictionary <DS, DS> tree, Operator <SS, DS>[] Ops, SS ss)
{
DS Prev;
DS Cur = SPgoal;
Path <SS, DS> Path = new Path <SS, DS>((DS)null);
do
{
Prev = Cur;
Cur = tree.Lookup(Prev);
if (Path.StateHashTable.Contains(Cur))
{
return(Path);
}
var Op = GetOp(Cur, Prev, Ops, ss);
if (Op == null)
{
return(Path);
}
Path.PushFirst(Op, Cur, Prev);
} while (!Cur.Equals(Sstart));
return(Path);
}
private static void Dijkstra(ref ExtendedDictionary <DS, Metric> G,
ExtendedDictionary <DS, Metric> H, DS Sstart, DS Sgoal,
ref ExtendedDictionary <DS, DS> tree,
ref PriorityQueue <Metric, DS> OPEN, ref HashSet <DS> CLOSED,
Operator <SS, DS>[] Ops, SS ss, Func <DS, DS, Metric> h0)
{
foreach (DS s in CLOSED)
{
H.Set(s, Metric.Infinity);
}
OPEN = OPEN.Reorder(s => H.Lookup(s));
while (CLOSED.Count != 0 && !OPEN.IsEmpty( ))
{
DS s = OPEN.Dequeue( );
if (CLOSED.Contains(s))
{
CLOSED.Remove(s);
}
foreach (DS sp in s.Expand(Ops, ss, false))
{
Metric cost = c(sp, s, h0) + H.Lookup(s);
if (CLOSED.Contains(sp) && H.Lookup(sp) > cost)
{
H.Set(sp, cost);
if (!OPEN.Contains(sp))
{
OPEN.Enqueue(cost, sp);
}
}
}
}
}
public void Reload(Settings settings, string currentFilePath)
{
_mappingToDstFileContainerMap.Clear();
_currentFilePath = null;
var dstFilePathToDstWordsCache = new ExtendedDictionary <string, ISet <Word> >(); // dstFilePath -> ISet<dstWord>
foreach (var mappingItem in settings.Mapping)
{
var dst = mappingItem.Dst;
var dstFilePath = dst.FullPath;
var fileDstWords = dstFilePathToDstWordsCache.ComputeIfAbsent(dstFilePath, key => new HashSet <Word>());
fileDstWords.Add(dst.Word);
}
IExtendedDictionary <DstLocation, DstFileContainer> dstContainerCache = new ExtendedDictionary <DstLocation, DstFileContainer>();
foreach (var mappingItem in settings.Mapping)
{
var supportedWords = dstFilePathToDstWordsCache[mappingItem.Dst.FullPath];
var dstFileContainer = dstContainerCache.ComputeIfAbsent(mappingItem.Dst, dst => new DstFileContainer(_parser, dst.FullPath, supportedWords));
_mappingToDstFileContainerMap[mappingItem] = dstFileContainer;
}
SwitchContext(currentFilePath);
}
public void TestBrackets_Expected3And6()
{
var a = new ExtendedDictionary<int, int, int>();
a[1, 2] = 3;
a[4, 5] = 6;
Assert.AreEqual(3, a[1, 2]);
Assert.AreEqual(6, a[4, 5]);
}
public void TestFastAccessById_ExpectedMas_2_5()
{
var a = new ExtendedDictionary<string, int, int>();
a.Add("test", 1, 2);
a.Add("test", 4, 5);
a.Add("no_test", 6, 7);
Assert.AreEqual(new int[]{2,5}, a.GetById("test"));
}
/// <summary>
/// The compute method which uses greedy search.
/// </summary>
/// <param name="StaticState">A static state to work on.</param>
/// <param name="DynamicState">A dynamic state to work on.</param>
/// <param name="Goal">The goal state(s) to search for.</param>
/// <returns>Computes a path.</returns>
public override IEnumerable <Path <SS, DS> > Compute(SS StaticState,
DS DynamicState, Goal <SS, DS> Goal, Operator <SS, DS>[] Actions)
{
ExtendedDictionary <DS, DS> tree = new ExtendedDictionary <DS, DS>(x => null);
ExtendedDictionary <DS, Metric> G = new ExtendedDictionary <DS, Metric>(k => Metric.Infinity);
G.Set(DynamicState, Metric.Zero);
uint IterationExpansions = 0;
PriorityQueue <Metric, DS> OpenList = new PriorityQueue <Metric, DS>( );
HashSet <DS> ClosedList = new HashSet <DS>( );
OpenList.Enqueue(Metric.Zero, DynamicState);
while (true)
{
if (OpenList.IsEmpty( ))
{
throw new PathNotFoundException("Path Not Found");
}
DS Cur = OpenList.Dequeue( );
ClosedList.Add(Cur);
if (Goal.IsSatisfiedBy(StaticState, Cur))
{
yield return(Algorithm <SS, DS> .ExtractPath(StaticState.InitialDynamicState,
Cur, tree, Actions, StaticState));
yield break;
}
else
{
this.Expansions++;
IterationExpansions++;
if (IterationExpansions > ComputationLimit)
{
yield return(Algorithm <SS, DS> .ExtractPath(StaticState.InitialDynamicState,
Cur, tree, Actions, StaticState));
IterationExpansions = 1;
}
foreach (DS e in Cur.Expand(Actions, StaticState, true))
{
if (!ClosedList.Contains(e))
{
Metric cost = G.Lookup(Cur) + e.LastOperator.Cost(Cur);
if (G.Lookup(e) > cost)
{
G.Set(e, cost);
tree.Set(e, Cur);
OpenList.Enqueue(cost, e);
}
}
this.Generations++;
}
}
}
}
public void TestCount_Expected_5()
{
var a = new ExtendedDictionary<int, string, int>();
a.Add(2, "test", 2);
a.Add(3, "test", 5);
a.Add(5, "no_test", 7);
a.Add(6, "no_test", 7);
a.Add(7, "no_test", 7);
Assert.AreEqual(5, a.Count);
}
static void Main(string[] args)
{
//Лёгкая демонстрация.
ExtendedDictionary<UserType, int, string> a = new ExtendedDictionary<UserType, int, string>();
#region Заполнение базы
a[ new UserType("Nikita", 23), 37] = "Programmer";
a[ new UserType("Nikita", 23), 666] = "Clone";
a[ new UserType("Andrey", 33), 38] = "1st Programmer";
a[ new UserType("Nikolay", 13), 39] = "Bad Programmer";
a[ new UserType("Alex", 93), 375] = "Ex Programmer";
a[ new UserType("Marina", 43), 371] = "Seller";
a[ new UserType("Daniil", 20), 370] = "Dealer";
a[ new UserType("Dima", 25), 3722] = "Worker";
a.Add(new UserType("Misha", 13), 37333, "Human");
a.Add(new UserType("Vasya", 53), 3711, "Slave");
a.Add(new UserType("Yulia", 22), 377, "Runer");
a.Add(new UserType("Bruce", 40), 3766, "Batman");
#endregion
Console.WriteLine("Какую должность занимает Юля с id=377? :\n" + a[new UserType("Yulia", 22), 377]);
Console.WriteLine();
Console.WriteLine("Люди, имеющие сигнатуру <'Nikita', 23> занимают должности:");
foreach (var item in a.GetById(new UserType("Nikita", 23)))
{
Console.WriteLine(item);
}
Console.WriteLine();
Console.WriteLine("Должности людей с id = 375:");
foreach (var item in a.GetByName(375))
{
Console.WriteLine(item);
}
Console.WriteLine();
var b= new ExtendedDictionary<int, string, int>();
b.Add(2, "test", 0);
Console.WriteLine();
Console.WriteLine("Выведем все значения в базе:");
Console.WriteLine("Name/Age signature".PadRight(12) +"| id".PadRight(8) + " | Possition\n");
foreach (var item in a)
{
Console.WriteLine(item.Key + " " + item.Value);
}
Console.ReadLine();
}
private static void AStar(ref ExtendedDictionary <DS, Metric> G,
ExtendedDictionary <DS, Metric> H, DS Sstart, DS Sgoal,
ExtendedDictionary <DS, DS> tree, ref PriorityQueue <Metric, DS> OPEN,
ref HashSet <DS> CLOSED, int lookahead, Operator <SS, DS>[] Ops, SS ss,
Func <DS, DS, Metric> h0, ref uint Expansions, StateVisualizer <SS, DS> sv)
{
G = new ExtendedDictionary <DS, Metric>(k => Metric.Infinity);
G.Set(Sstart, Metric.Zero);
OPEN = new PriorityQueue <Metric, DS>( );
CLOSED = new HashSet <DS>( );
OPEN.Enqueue(H.Lookup(Sstart), Sstart);
int expansions = 0;
while (!OPEN.IsEmpty( ) && G.Lookup(Sgoal) > OPEN.TopKey( ) &&
expansions < lookahead)
{
#if OpenGl
if (sv != null)
{
HashSet <DS> hs = new HashSet <DS>( );
OPEN.AddToHashSet(hs);
sv.VisualizeAlg(ss, ss.InitialDynamicState, new OpenGLStateVisualizer.OpenGlVisulizationData( )
{
List = hs as HashSet <GenericGridWorldDynamicState>,
HAdjusted = H,
});
}
#endif
expansions++;
DS s = OPEN.Dequeue( );
CLOSED.Add(s);
Expansions++;
foreach (DS sp in s.Expand(Ops, ss, false))
{
Metric cost = G.Lookup(s) + c(s, sp, h0);
if (G.Lookup(sp) > cost)
{
G.Set(sp, cost);
tree.Set(sp, s);
if (OPEN.Contains(sp))
{
OPEN.Remove(sp);
}
OPEN.Enqueue(G.Lookup(sp) + H.Lookup(sp), sp);
}
}
}
}
public override IEnumerable <Path <SS, DS> > Compute(SS ss, DS ds, Goal <SS, DS> Goal, Operator <SS, DS>[] Ops)
{
this.init(ss, ds, Ops, Goal);
ExtendedDictionary <DS, Metric> H1 = new ExtendedDictionary <DS, Metric>(x => aS.h(x, aS.Sgoal));
ExtendedDictionary <DS, DS> tree = new ExtendedDictionary <DS, DS>(x => null);
Path <SS, DS> Incumbant = null;
int GlobalSearchLimit = GetGlobalSearchComputationLimit( );
this.aS.ComputationLimit = GlobalSearchLimit;
int LocalSearchLimit = GetLocalSearchComputationLimit( );
foreach (Path <SS, DS> p in AnytimeDStarLiteLookahead(aS, GlobalSearchLimit))
{
this.Expansions += aS.Expansions;
this.Generations += aS.Generations;
aS.Expansions = 0;
aS.Generations = 0;
if (p == null)
{
switch (sm)
{
/*case ChooseMethodStep.LRTAStar:
* yield return LRTAStar<SS, DS>.AStarLookAhead( ss.InitialDynamicState, ss,
* LocalSearchLimit, aS.sv,
* ref this.Expansions, ref this.Generations, false,
* Ops, H1, H, Goal, Metric.One, false );
* break;
* case ChooseMethodStep.RTAStar:
* yield return LRTAStar<SS, DS>.AStarLookAhead( ss.InitialDynamicState, ss,
* LocalSearchLimit, aS.sv,
* ref this.Expansions, ref this.Generations, false,
* Ops, H1, H, Goal, Metric.One, true );
* break;*/
case ChooseMethodStep.LSSLRTAStar:
yield return(LSSLRTAStar <SS, DS> .LSSLRTAStarLookahead(LocalSearchLimit, ss, aS.Sstart,
aS.Sgoal, Ops, aS.h, ref Incumbant, ref this.Expansions, aS.sv, tree, H1));
break;
}
}
else
{
yield return(p);
}
aS.Sstart = aS.ss.InitialDynamicState;
}
yield break;
}
public void TestEnumirable_Expected_5()
{
var a = new ExtendedDictionary<int, string, int>();
a.Add(2, "test", 2);
a.Add(3, "test", 5);
a.Add(5, "no_test", 7);
a.Add(6, "no_test", 7);
a.Add(7, "no_test", 7);
int tmp = 0;
foreach (var item in a)
{
tmp++;
}
Assert.AreEqual(5, tmp);
}
public override IEnumerable <Path <SS, DS> > Compute(SS ss,
DS Sstart, Goal <SS, DS> Goal, Operator <SS, DS>[] Ops)
{
DS Sgoal = Transformer.Transform(Goal, Sstart);
Func <DS, DS, Metric> h0 = (x, y) => Heuristic.H(ss, x, y, Ops);
ExtendedDictionary <DS, DS> tree = new ExtendedDictionary <DS, DS>(x => null);
ExtendedDictionary <DS, Metric> H = new ExtendedDictionary <DS, Metric>(
x => h0(x, Sgoal));
Path <SS, DS> Incumbant = null;
while (!Sstart.Equals(Sgoal))
{
yield return(LSSLRTAStarLookahead(ComputationLimit, ss, Sstart, Sgoal,
Ops, h0, ref Incumbant, ref Expansions, sv, tree, H));
Sstart = ss.InitialDynamicState;
}
yield break;
}
public override void Awake()
{
base.Awake();
FilePath = CombineFilePath(fileName);
qLambdaTable = new ExtendedDictionary <State, EQValues>(new StateEqualityComparer());
if (!File.Exists(FilePath) || new FileInfo(FilePath).Length == 0)
{
qLambdaTable = new ExtendedDictionary <State, EQValues>(new StateEqualityComparer());
}
else
{
qLambdaTable = new ReadQLambdaDictionaryFromFile(FilePath).QLambdaDictionary;
}
if (startLearning)
{
qLambdaTable = new ExtendedDictionary <State, EQValues>(new StateEqualityComparer());
ResetETable();
}
}
private void init(Goal <SS, DS> Goal, SS ss, DS Sstart,
Operator <SS, DS>[] Actions)
{
LockedList = new HashSet <DS>( );
RHS = new Dictionary <string, Metric>( );
G = new Dictionary <string, Metric>( );
HAdjusted = new Dictionary <string, Metric>( );
this.Sgoal = Transformer.Transform(Goal, Sstart);
this.Sstart = Sstart;
this.ss = ss;
this.Ops = Actions;
us = new USample( );
switch (this.sm)
{
case ChooseMethodStep.LSSLRTAStar:
h0 = (x, y) => H.H(ss, x, y, Actions);
tree = new ExtendedDictionary <DS, DS>(X => null);
HLSS = new ExtendedDictionary <DS, Metric>(x => h0(x, Sgoal));
Incumbant = null;
break;
}
}
public static Path <SS, DS> LSSLRTAStarLookahead(int ComputationLimit, SS ss,
DS Sstart, DS Sgoal, Operator <SS, DS>[] Ops, Func <DS, DS, Metric> h0,
ref Path <SS, DS> Incumbant, ref uint Expansions, StateVisualizer <SS, DS> sv,
ExtendedDictionary <DS, DS> tree, ExtendedDictionary <DS, Metric> H)
{
if (!PathGood(Incumbant, ss))
{
ExtendedDictionary <DS, Metric> G = null;
PriorityQueue <Metric, DS> OPEN = null;
HashSet <DS> CLOSED = null;
AStar(ref G, H, Sstart, Sgoal, tree, ref OPEN, ref CLOSED, ComputationLimit, Ops, ss, h0, ref Expansions, sv);
if (OPEN.IsEmpty( ))
{
return(null);
}
DS SPgoal = OPEN.Top( );
Dijkstra(ref G, H, Sstart, Sgoal, ref tree, ref OPEN, ref CLOSED, Ops, ss, h0);
Incumbant = ExtractPath(Sstart, SPgoal, tree, Ops, ss);
}
if (Incumbant == null || Incumbant.ActionCount == 0)
{
return(null);
}
else
{
var IHead = Incumbant.PopHead( );
if (IHead.Actions.First.Value.IsValidOn(ss.InitialDynamicState, ss, false))
{
return(IHead);
}
else
{
Incumbant = null;
return(null);
}
}
}
/// <summary>
/// The compute method which uses greedy search.
/// </summary>
/// <param name="StaticState">A static state to work on.</param>
/// <param name="DynamicState">A dynamic state to work on.</param>
/// <param name="Goal">The goal state(s) to search for.</param>
/// <returns>Computes a path.</returns>
public override IEnumerable <Path <SS, DS> > Compute(SS StaticState,
DS DynamicState, Goal <SS, DS> Goal, Operator <SS, DS>[] Actions)
{
HashSet <DS> DeadEndList = new HashSet <DS>( );
InStateGoal <SS, DS> FakeGoal = new InStateGoal <SS, DS>(DynamicState);
DS GoalState = Transformer.Transform(Goal, DynamicState);
uint IterationExpansions = 0;
ExtendedDictionary <DS, DS> tree = new ExtendedDictionary <DS, DS>(x => null);
ExtendedDictionary <DS, Metric> G = new ExtendedDictionary <DS, Metric>(k => Metric.Infinity);
G.Set(DynamicState, Metric.Zero);
PriorityQueue <Metric, DS> OpenList = new PriorityQueue <Metric, DS>( );
HashSet <DS> ClosedList = new HashSet <DS>( );
OpenList.Enqueue(Metric.Zero, GoalState);
while (true)
{
if (OpenList.IsEmpty( ))
{
throw new PathNotFoundException("Path Not Found");
}
var Cur = OpenList.DequeueNode( );
ClosedList.Add(Cur.Second);
if (FakeGoal.IsSatisfiedBy(StaticState, Cur.Second))
{
LinkedList <Operator <SS, DS> > Operators = new LinkedList <Operator <SS,
DS> >( );
foreach (var a in Algorithm <SS, DS> .ExtractPath(StaticState.InitialDynamicState,
Cur.Second, tree, Actions, StaticState).Actions)
{
Operators.AddFirst(new ReverseOperator <SS, DS>(a));
}
yield return(new Path <SS, DS>((DS)null)
{
Actions = Operators
});
yield break;
}
else
{
this.Expansions++;
if (++IterationExpansions >= ComputationLimit)
{
IEnumerable <DS> dss = DynamicState.Expand(Actions, StaticState,
true).Where(
ds => !DeadEndList.Contains(ds));
if (dss.All(ds => HeuristicSS.H(StaticState, ds, Cur.Second,
Actions) >
HeuristicSS.H(StaticState, DynamicState, Cur.Second, Actions))
)
{
DeadEndList.Add(DynamicState);
}
if (!dss.Any( ))
{
dss = DynamicState.Expand(Actions, StaticState, true);
}
DS s = dss.ArgMin(
ds => HeuristicSS.H(StaticState, ds, Cur.Second, Actions));
var p = Algorithm <SS, DS> .ExtractPath(StaticState.InitialDynamicState,
Cur.Second, tree, Actions, StaticState);
yield return(p);
DynamicState = p.Actions.First( ).PerformOn(DynamicState,
StaticState).First( );
if (OpenList.Contains(DynamicState))
{
DS st;
do
{
st = OpenList.Dequeue( );
} while (!st.Equals(DynamicState)); //TODO add method for this.
LinkedList <Operator <SS, DS> > Operators =
new LinkedList <Operator <SS, DS> >( );
foreach (var a in Algorithm <SS, DS> .ExtractPath(StaticState.InitialDynamicState,
st, tree, Actions, StaticState).Actions)
{
Operators.AddFirst(new ReverseOperator <SS, DS>(a));
}
yield return(new Path <SS, DS>((DS)null)
{
Actions = Operators
});
yield break;
}
if (ClosedList.Contains(DynamicState))
{
LinkedList <Operator <SS, DS> > Operators =
new LinkedList <Operator <SS, DS> >( );
var pgot = Algorithm <SS, DS> .ExtractPath(StaticState.InitialDynamicState,
ClosedList.First(ds => ds.Equals(
DynamicState)), tree, Actions, StaticState);
foreach (var a in pgot.Actions)
{
Operators.AddFirst(new ReverseOperator <SS, DS>(a));
}
yield return(new Path <SS, DS>((DS)null)
{
Actions = Operators
});
yield break;
}
FakeGoal = new InStateGoal <SS, DS>(DynamicState);
IterationExpansions = 0;
OpenList.Enqueue(Cur.First, Cur.Second);
if (Sort)
{
/*PriorityQueue<Metric, DS> sortedOpen =
* new PriorityQueue<Metric, DS>( );
* DS x;
* while ( ( x = OpenList.Dequeue( ) ) != null ) {
* sortedOpen.Enqueue( G.Lookup( Cur.Second ) + e.LastOperator.Cost( Cur.Second ), x );
* }
* OpenList = sortedOpen;
*/
}
}
else
{
foreach (DS e in Cur.Second.Expand(Actions, StaticState, true
))
{
if (!ClosedList.Contains(e) && !OpenList.Contains(e))
{
Metric cost = G.Lookup(Cur.Second) + e.LastOperator.Cost(Cur.Second);
if (G.Lookup(e) > cost)
{
G.Set(e, cost);
tree.Set(e, Cur.Second);
OpenList.Enqueue(cost, e);
}
}
this.Generations++;
}
}
}
}
}
public QLambdaDictionaryToFile(string filePath, ExtendedDictionary <State, EQValues> qLambdaDictionary) : base(filePath)
{
FilePath = filePath;
QLambdaDict = qLambdaDictionary;
DictionaryToFile();
}
// Use this for initialization
private void Awake()
{
m_Character = GetComponent <PlatformerCharacter2D>();
dic = new ExtendedDictionary <State, float[]>(new StateEqualityComparer());
}
public ExpressionParserTestFixture()
{
AssignmentOperator = ("=", 1, AssociativityType.Right, (lhs, rhs) => (((Variable)lhs).Value = rhs));
EscapeSequenceFormatter = new ExtendedNativeEscapeSequenceFormatter();
CustomVariables = new Dictionary <string, Variable>();
Results = new List <object>();
ArithmeticUnaryOperators = new ExtendedDictionary <char, UnaryOperator>((value) => value.Identifier)
{
('+', 1, AssociativityType.Right, (value) => + System.Convert.ToDouble(value)),
('-', 1, AssociativityType.Right, (value) => - System.Convert.ToDouble(value)),
('!', 1, AssociativityType.Right, (value) => { double tmp = System.Convert.ToDouble(value); return(tmp == 0D || tmp == double.NaN); })
};
ArithmeticBinaryOperators = new ExtendedDictionary <string, BinaryOperator>((value) => value.Identifier)
{
("+", 4, AssociativityType.Left, (lhs, rhs) => lhs is string || rhs is string?(object)$"{lhs}{rhs}" : (object)(System.Convert.ToDouble(lhs) + System.Convert.ToDouble(rhs))),
("-", 4, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) - System.Convert.ToDouble(rhs)),
("*", 3, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) * System.Convert.ToDouble(rhs)),
("/", 3, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) / System.Convert.ToDouble(rhs)),
("%", 3, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) % System.Convert.ToDouble(rhs)),
("^", 2, AssociativityType.Right, (lhs, rhs) => Exponentiation(lhs, rhs)),
("//", 3, AssociativityType.Right, (lhs, rhs) => Math.Truncate(System.Convert.ToDouble(lhs) / System.Convert.ToDouble(rhs))),
("**", 2, AssociativityType.Right, (lhs, rhs) => Exponentiation(lhs, rhs)),
("==", 5, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) == System.Convert.ToDouble(lhs)),
("!=", 5, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) != System.Convert.ToDouble(lhs)),
("<", 5, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) < System.Convert.ToDouble(lhs)),
(">", 5, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) > System.Convert.ToDouble(lhs)),
("<=", 5, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) <= System.Convert.ToDouble(lhs)),
(">=", 5, AssociativityType.Left, (lhs, rhs) => System.Convert.ToDouble(lhs) >= System.Convert.ToDouble(lhs))
};
ArithmeticVariables = new ExtendedDictionary <string, Variable>((value) => value.Identifier)
{
("T", 1000000000000.0),
("G", 1000000000.0),
("M", 1000000.0),
("k", 1000.0),
("h", 100.0),
("da", 10.0),
("d", 0.1),
("c", 0.01),
("m", 0.001),
("u", 0.000001),
("n", 0.000000001),
("p", 0.000000000001),
("math.pi", Math.PI),
("math.e", Math.E),
("phys.c", 299792458),
("phys.au", 149597870700)
};
ArithmeticFunctions = new ExtendedDictionary <string, Function>((value) => value.Identifier)
{
("ans", 0, 1, Ans),
("pi", 0, PI),
("abs", 1, (args) => Math.Abs(System.Convert.ToDouble(args[0]))),
("neg", 1, (args) => - Math.Abs(System.Convert.ToDouble(args[0]))),
("pow", 2, Exponentiation),
("root", 2, Root),
("sqrt", 1, (args) => Math.Sqrt(System.Convert.ToDouble(args[0]))),
("cbrt", 1, (args) => Root(args[0], 3)),
("log", 1, (args) => Math.Log(System.Convert.ToDouble(args[0]))),
("log10", 1, (args) => Math.Log10(System.Convert.ToDouble(args[0]))),
("sin", 1, (args) => Math.Sin(System.Convert.ToDouble(args[0]))),
("cos", 1, (args) => Math.Cos(System.Convert.ToDouble(args[0]))),
("tan", 1, (args) => Math.Tan(System.Convert.ToDouble(args[0]))),
("asin", 1, (args) => Math.Asin(System.Convert.ToDouble(args[0]))),
("acos", 1, (args) => Math.Acos(System.Convert.ToDouble(args[0]))),
("atan", 1, (args) => Math.Atan(System.Convert.ToDouble(args[0]))),
("sinh", 1, (args) => Math.Sinh(System.Convert.ToDouble(args[0]))),
("cosh", 1, (args) => Math.Cosh(System.Convert.ToDouble(args[0]))),
("tanh", 1, (args) => Math.Tanh(System.Convert.ToDouble(args[0]))),
("asinh", 1, (args) => Math.Asinh(System.Convert.ToDouble(args[0]))),
("acosh", 1, (args) => Math.Acosh(System.Convert.ToDouble(args[0]))),
("atanh", 1, (args) => Math.Atanh(System.Convert.ToDouble(args[0]))),
("min", 1, -1, Min),
("max", 1, -1, Max),
("strlen", 1, StringLength)
};
ArithmeticShorthandOperator = ("*", 3, AssociativityType.Right, (lhs, rhs) => System.Convert.ToDouble(lhs) * System.Convert.ToDouble(rhs));
ArithmeticExpressionParser = new ExpressionParser(ArithmeticUnaryOperators, ArithmeticBinaryOperators, ArithmeticVariables, ArithmeticFunctions, CustomVariables, AssignmentOperator)
{
ShorthandOperator = ArithmeticShorthandOperator,
EscapeSequenceFormatter = EscapeSequenceFormatter
};
BitwiseVariables = new ExtendedDictionary <string, Variable>((value) => value.Identifier)
{
("false", 0),
("true", 1)
};
BitwiseFunctions = new ExtendedDictionary <string, Function>((value) => value.Identifier)
{
};
BitwiseUnaryOperators = new ExtendedDictionary <char, UnaryOperator>((value) => value.Identifier)
{
('!', 1, AssociativityType.Right, (value) => System.Convert.ToInt32(value) != 0 ? 0 : 1),
('~', 1, AssociativityType.Right, (value) => ~System.Convert.ToInt32(value))
};
BitwiseBinaryOperators = new ExtendedDictionary <string, BinaryOperator>((value) => value.Identifier)
{
("+", 5, AssociativityType.Left, (lhs, rhs) => System.Convert.ToInt32(lhs) | System.Convert.ToInt32(rhs)),
("*", 3, AssociativityType.Left, (lhs, rhs) => System.Convert.ToInt32(lhs) & System.Convert.ToInt32(rhs)),
("^", 4, AssociativityType.Left, (lhs, rhs) => System.Convert.ToInt32(lhs) ^ System.Convert.ToInt32(rhs)),
("<<", 2, AssociativityType.Right, (lhs, rhs) => System.Convert.ToInt32(lhs) << System.Convert.ToInt32(rhs)),
(">>", 2, AssociativityType.Left, (lhs, rhs) => System.Convert.ToInt32(lhs) >> System.Convert.ToInt32(rhs))
};
BitwiseShorthandOperator = ("*", 3, AssociativityType.Right, (lhs, rhs) => System.Convert.ToInt32(lhs) & System.Convert.ToInt32(rhs));
BitwiseExpressionParser = new ExpressionParser(BitwiseUnaryOperators, BitwiseBinaryOperators, BitwiseVariables, BitwiseFunctions, CustomVariables, AssignmentOperator)
{
ShorthandOperator = BitwiseShorthandOperator,
EscapeSequenceFormatter = EscapeSequenceFormatter
};
}
public void TestParallelModificationSafity_Expected_4950()
{
var a = new ExtendedDictionary<int, string, int>();
a.Add(2, "test", 0);
Parallel.For(0, 100,
(i) =>
{
a.EnterUpgradeableReadLock();
a[2, "test"] += i;
a.ExitUpgradeableReadLock();
});
Assert.AreEqual(4950, a[2, "test"]);
}
public ReadQLambdaDictionaryFromFile(string filePath) : base(filePath)
{
FilePath = filePath;
QLambdaDictionary = new ExtendedDictionary <State, EQValues>(new StateEqualityComparer());
Read();
}
public void TestFastAccessByName_ExpectedMas_2_5()
{
var a = new ExtendedDictionary<int,string, int>();
a.Add(2,"test", 2);
a.Add(3,"test", 5);
a.Add(5,"no_test", 7);
Assert.AreEqual(new int[] { 2, 5 }, a.GetByName("test"));
}
public ReadQ0DictionaryFromFile(string filePath) : base(filePath)
{
FilePath = filePath;
Q0Dictionary = new ExtendedDictionary <State, float[]>(new StateEqualityComparer());
Read();
}
/// <summary>
/// The compute method which uses greedy search.
/// </summary>
/// <param name="StaticState">A static state to work on.</param>
/// <param name="DynamicState">A dynamic state to work on.</param>
/// <param name="Goal">The goal state(s) to search for.</param>
/// <returns>Computes a path.</returns>
public override Path <SS, DS> ComputeComplete(SS StaticState,
DS DynamicState, Goal <SS, DS> Goal, Operator <SS, DS>[] Actions)
{
PriorityQueue <Metric, DS> OpenList = new PriorityQueue <Metric, DS>( );
ExtendedDictionary <DS, DS> tree = new ExtendedDictionary <DS, DS>(x => null);
ExtendedDictionary <DS, Metric> G = new ExtendedDictionary <DS, Metric>(k => Metric.Infinity);
G.Set(DynamicState, Metric.Zero);
HashSet <DS> ClosedList = new HashSet <DS>( );
OpenList.Enqueue(Metric.Zero, DynamicState);
while (true)
{
#if OpenGl
if (sv != null)
{
this.sv.VisualizeAlg(StaticState, StaticState.InitialDynamicState,
new OpenGLStateVisualizer.OpenGlVisulizationData( )
{
OL = OpenList as PriorityQueue <Metric, GenericGridWorldDynamicState>,
});
}
#endif
if (OpenList.IsEmpty( ))
{
throw new PathNotFoundException("Path Not Found");
}
DS Cur = OpenList.Dequeue( );
if (UseClosedList)
{
ClosedList.Add(Cur);
}
if (Goal.IsSatisfiedBy(StaticState, Cur))
{
return(Algorithm <SS, DS> .ExtractPath(StaticState.InitialDynamicState,
Cur, tree, Actions, StaticState));
}
else
{
this.Expansions++;
foreach (DS e in Cur.Expand(Actions, StaticState, true))
{
e.BookKeeping = new ParentBookKeeping <SS, DS>( );
if (!UseClosedList)
{
(e.BookKeeping as ParentBookKeeping <SS, DS>).Parent = Cur;
}
if ((UseClosedList && !ClosedList.Contains(e) && !OpenList.Contains(e)) ||
(!UseClosedList && !CheckReversePathForDuplicates(e)))
{
Metric cost = G.Lookup(Cur) + e.LastOperator.Cost(Cur);
if (G.Lookup(e) > cost)
{
G.Set(e, cost);
tree.Set(e, Cur);
OpenList.Enqueue(cost, e);
}
}
this.Generations++;
}
}
}
}
public Q0DictionaryToFile(string filePath, ExtendedDictionary <State, float[]> q0Dictionary) : base(filePath)
{
FilePath = filePath;
Q0Dictionary = q0Dictionary;
DictionaryToFile();
}
