public void ThreeNumberTest()
{
var exp = new Var(new[] { new Number(9), new Number(2), new Number(4) }, 3);
var result = exp.Execute();
Assert.Equal(13.0, result);
}
public void TwoNumberTest()
{
var exp = new Var(new[] { new Number(4), new Number(9) }, 2);
var result = exp.Execute();
Assert.Equal(12.5, result);
}
public void OneNumberTest()
{
var exp = new Var(new[] { new Number(4) }, 1);
var result = exp.Execute();
Assert.Equal(double.NaN, result);
}
public DefExpr(Var var, Expr init, Expr meta, bool initProvided)
{
_var = var;
_init = init;
_meta = meta;
_initProvided = initProvided;
}
public DefExpr(string source, int line, Var var, Expr init, Expr meta, bool initProvided, bool isDyanamic)
{
_source = source;
_line = line;
_var = var;
_init = init;
_meta = meta;
_isDynamic = isDyanamic;
_initProvided = initProvided;
}
public static void VarVarVar()
{
Var a = "1";
Var b = 1;
Var c = "a";
Var list = new Var[] { 1, 2, 3 };
if (a + b) // "1" + 1 = "11". "11" is true like JavaScript.
{
long x = list ? 1 : 2; // list is VarList. VarList is true like JavaScript.
Console.WriteLine(x.ToString());
}
}
public DefExpr(string source, int line, int column, Var var, Expr init, Expr meta, bool initProvided, bool isDyanamic, bool shadowsCoreMapping)
{
_source = source;
_line = line;
_column = column;
_var = var;
_init = init;
_meta = meta;
_isDynamic = isDyanamic;
_shadowsCoreMapping = shadowsCoreMapping;
_initProvided = initProvided;
}
void Start()
{
Application.runInBackground = true;
rainSystem = GetComponent<ParticleSystem>();
rainEmissionRate = Var.Define("rainEmissionRate", 2000);
rainEmissionRate.ValueChanged += delegate() {
rainSystem.emissionRate = rainEmissionRate.Value < maxRate ? rainEmissionRate.Value : maxRate;
};
rainSystem.emissionRate = rainEmissionRate.Value < maxRate ? rainEmissionRate.Value : maxRate;
}
public override number _Simulate(Var S1, Var S2, int p1, int p2, ref int[] BranchIndex, int IndexOffset)
{
PocketData Data = (ActivePlayer == Player.Button ? S1 : S2)(this);
int pocket = ActivePlayer == Player.Button ? p1 : p2;
number CallEV = CallBranch._Simulate(S1, S2, p1, p2, ref BranchIndex, IndexOffset);
number FoldEV = ActivePlayer == Player.Button ? -Spent : Spent;
number EV = Data[pocket] * CallEV +
(1 - Data[pocket]) * FoldEV;
Assert.IsNum(EV);
return EV;
}
public void ToStringTest()
{
var sum = new Var(new[] { new Number(1), new Number(2) }, 2);
Assert.Equal("var(1, 2)", sum.ToString());
}
public override void Visit(UnionAllOp op, Node n)
{
#if DEBUG
var input = Dump.ToXml(n);
#endif
//DEBUG
// Ensure we have keys pulled up on each branch of the union all.
VisitChildren(n);
// Create the setOp var we'll use to output the branch discriminator value; if
// any of the branches are already surfacing a branchDiscriminator var to the
// output of this operation then we won't need to use this but we construct it
// early to simplify logic.
Var outputBranchDiscriminatorVar = m_command.CreateSetOpVar(m_command.IntegerType);
// Now ensure that we're outputting the key vars from this op as well.
var allKeyVarsMissingFromOutput = Command.CreateVarList();
var keyVarsMissingFromOutput = new VarVec[n.Children.Count];
for (var i = 0; i < n.Children.Count; i++)
{
var branchNode = n.Children[i];
var branchNodeInfo = m_command.GetExtendedNodeInfo(branchNode);
// Identify keys that aren't in the output list of this operation. We
// determine these by remapping the keys that are found through the node's
// VarMap, which gives us the keys in the same "varspace" as the outputs
// of the UnionAll, then we subtract out the outputs of this UnionAll op,
// leaving things that are not in the output vars. Of course, if they're
// not in the output vars, then we didn't really remap.
var existingKeyVars = branchNodeInfo.Keys.KeyVars.Remap(op.VarMap[i]);
keyVarsMissingFromOutput[i] = m_command.CreateVarVec(existingKeyVars);
keyVarsMissingFromOutput[i].Minus(op.Outputs);
// Special Case: if the branch is a UnionAll, it will already have it's
// branch discriminator var added in the keys; we don't want to add that
// a second time...
if (OpType.UnionAll
== branchNode.Op.OpType)
{
var branchUnionAllOp = (UnionAllOp)branchNode.Op;
keyVarsMissingFromOutput[i].Clear(branchUnionAllOp.BranchDiscriminator);
}
allKeyVarsMissingFromOutput.AddRange(keyVarsMissingFromOutput[i]);
}
// Construct the setOp vars we're going to map to output.
var allKeyVarsToAddToOutput = Command.CreateVarList();
foreach (var v in allKeyVarsMissingFromOutput)
{
Var newKeyVar = m_command.CreateSetOpVar(v.Type);
allKeyVarsToAddToOutput.Add(newKeyVar);
}
// Now that we've identified all the keys we need to add, ensure that each branch
// has both the branch discrimination var and the all the keys in them, even when
// the keys are just going to null (which we construct, as needed)
for (var i = 0; i < n.Children.Count; i++)
{
var branchNode = n.Children[i];
var branchNodeInfo = m_command.GetExtendedNodeInfo(branchNode);
var branchOutputVars = m_command.CreateVarVec();
var varDefNodes = new List <Node>();
// If the branch is a UnionAllOp that has a branch discriminator var then we can
// use it, otherwise we'll construct a new integer constant with the next value
// of the branch discriminator value from the command object.
Var branchDiscriminatorVar;
if (OpType.UnionAll == branchNode.Op.OpType &&
null != ((UnionAllOp)branchNode.Op).BranchDiscriminator)
{
branchDiscriminatorVar = ((UnionAllOp)branchNode.Op).BranchDiscriminator;
// If the branch has a discriminator var, but we haven't added it to the
// varmap yet, then we do so now.
if (!op.VarMap[i].ContainsValue(branchDiscriminatorVar))
{
op.VarMap[i].Add(outputBranchDiscriminatorVar, branchDiscriminatorVar);
// We don't need to add this to the branch outputs, because it's already there,
// otherwise we wouln't have gotten here, yes?
}
else
{
// In this case, we're already outputting the branch discriminator var -- we'll
// just use it for both sides. We should never have a case where only one of the
// two branches are outputting the branch discriminator var, because it can only
// be constructed in this method, and we wouldn't need it for any other purpose.
PlanCompiler.Assert(0 == i, "right branch has a discriminator var that the left branch doesn't have?");
var reverseVarMap = op.VarMap[i].GetReverseMap();
outputBranchDiscriminatorVar = reverseVarMap[branchDiscriminatorVar];
}
}
else
{
// Not a unionAll -- we have to add a BranchDiscriminator var.
varDefNodes.Add(
m_command.CreateVarDefNode(
m_command.CreateNode(
m_command.CreateConstantOp(m_command.IntegerType, m_command.NextBranchDiscriminatorValue)),
out branchDiscriminatorVar));
branchOutputVars.Set(branchDiscriminatorVar);
op.VarMap[i].Add(outputBranchDiscriminatorVar, branchDiscriminatorVar);
}
// Append all the missing keys to the branch outputs. If the missing key
// is not from this branch then create a null.
for (var j = 0; j < allKeyVarsMissingFromOutput.Count; j++)
{
var keyVar = allKeyVarsMissingFromOutput[j];
if (!keyVarsMissingFromOutput[i].IsSet(keyVar))
{
varDefNodes.Add(
m_command.CreateVarDefNode(
m_command.CreateNode(
m_command.CreateNullOp(keyVar.Type)), out keyVar));
branchOutputVars.Set(keyVar);
}
// In all cases, we're adding a key to the output so we need to update the
// varmap.
op.VarMap[i].Add(allKeyVarsToAddToOutput[j], keyVar);
}
// If we got this far and didn't add anything to the branch, then we're done.
// Otherwise we'll have to construct the new projectOp around the input branch
// to add the stuff we've added.
if (branchOutputVars.IsEmpty)
{
// Actually, we're not quite done -- we need to update the key vars for the
// branch to include the branch discriminator var we
branchNodeInfo.Keys.KeyVars.Set(branchDiscriminatorVar);
}
else
{
PlanCompiler.Assert(varDefNodes.Count != 0, "no new nodes?");
// Start by ensuring all the existing outputs from the branch are in the list.
foreach (var v in op.VarMap[i].Values)
{
branchOutputVars.Set(v);
}
// Now construct a project op to project out everything we've added, and
// replace the branchNode with it in the flattened ladder.
n.Children[i] = m_command.CreateNode(
m_command.CreateProjectOp(branchOutputVars),
branchNode,
m_command.CreateNode(m_command.CreateVarDefListOp(), varDefNodes));
// Finally, ensure that we update the Key info for the projectOp to include
// the original branch's keys, along with the branch discriminator var.
m_command.RecomputeNodeInfo(n.Children[i]);
var projectNodeInfo = m_command.GetExtendedNodeInfo(n.Children[i]);
projectNodeInfo.Keys.KeyVars.InitFrom(branchNodeInfo.Keys.KeyVars);
projectNodeInfo.Keys.KeyVars.Set(branchDiscriminatorVar);
}
}
// All done with the branches, now it's time to update the UnionAll op to indicate
// that we've got a branch discriminator var.
n.Op = m_command.CreateUnionAllOp(op.VarMap[0], op.VarMap[1], outputBranchDiscriminatorVar);
// Finally, the thing we've all been waiting for -- computing the keys. We cheat here and let
// nodeInfo do it so we don't have to duplicate the logic...
m_command.RecomputeNodeInfo(n);
#if DEBUG
input = input.Trim();
var output = Dump.ToXml(n);
#endif
//DEBUG
}
private void showSubscriberFeedsResultList(Var resultList)
{
System.Console.Out.WriteLine("\nAll Subscriber Feeds:");
Struct feedList = (Struct)resultList.getTerm();
while (!feedList.isEmptyList())
{
Struct subscriberFeed = (Struct)feedList.getArg(0)
.getTerm();
feedList = (Struct)feedList.getArg(1).getTerm();
// System.Console.Out.WriteLine(" " + subscriberFeed.ToString());
Struct subscriber = (Struct)subscriberFeed.getArg(0)
.getTerm();
Struct articleList = (Struct)subscriberFeed.getArg(1)
.getTerm();
// System.Console.Out.WriteLine(" " + subscriber.getName() + " "
// + articleList.ToString());
System.Console.Out.WriteLine("\n Feed for " + subscriber.getName()
+ ":");
while (!articleList.isEmptyList())
{
Struct article = (Struct)articleList.getArg(0)
.getTerm();
articleList = (Struct)articleList.getArg(1)
.getTerm();
String articleId = PrologLibrary
.stringValueFromTerm(article.getArg(0));
String provider = PrologLibrary
.stringValueFromTerm(article.getArg(1));
String contents = PrologLibrary
.stringValueFromTerm(article.getArg(2));
System.Console.Out.WriteLine(" #" + articleId.ToString()
+ " from " + provider + ": " + contents);
}
}
System.Console.Out.WriteLine("\n(End of Feeds.)");
}
/// <summary>
/// Create a new VarInfo for a structured type Var where the newVars cannot include a null sentinel
/// </summary>
/// <param name="v"> The structured type Var </param>
/// <param name="newType"> "Mapped" type for v </param>
/// <param name="newVars"> List of vars corresponding to v </param>
/// <param name="newProperties"> Flattened Properties </param>
internal VarInfo CreateStructuredVarInfo(Var v, RowType newType, List <Var> newVars, List <EdmProperty> newProperties)
{
return(CreateStructuredVarInfo(v, newType, newVars, newProperties, false));
}
/// <summary>
/// Public entry point.
/// Remaps the subree rooted at the given tree
/// </summary>
internal static void RemapSubtree(Node root, Command command, Var oldVar)
{
var remapper = new VarDefinitionRemapper(oldVar, command);
remapper.RemapSubtree(root);
}
public override number _Simulate(Var S1, Var S2, int p1, int p2, ref int[] BranchIndex, int IndexOffset)
{
uint PocketValue1 = PocketValue[p1];
uint PocketValue2 = PocketValue[p2];
if (PocketValue1 == PocketValue2)
return 0;
else if (PocketValue1 > PocketValue2)
return Pot;
else
return -Pot;
}
public static number _Simulation(Var S1, Var S2, PocketRoot root)
{
number EV = 0, TotalMass = 0;
for (int p1 = 0; p1 < Pocket.N; p1++)
{
number PocketEV = 0, PocketTotalMass = 0;
for (int p2 = 0; p2 < Pocket.N; p2++)
{
if (Pocket.Pockets[p1].Overlaps(Pocket.Pockets[p2])) continue;
for (int flop = 0; flop < Flop.N; flop++)
{
if (Pocket.Pockets[p1].Overlaps(Flop.Flops[flop])) continue;
if (Pocket.Pockets[p2].Overlaps(Flop.Flops[flop])) continue;
for (int turn = 0; turn < Card.N; turn++)
{
if (Flop.Flops[flop].Contains(turn)) continue;
if (Pocket.Pockets[p1].Contains(turn)) continue;
if (Pocket.Pockets[p2].Contains(turn)) continue;
for (int river = 0; river < Card.N; river++)
{
if (turn == river) continue;
if (Flop.Flops[flop].Contains(river)) continue;
if (Pocket.Pockets[p1].Contains(river)) continue;
if (Pocket.Pockets[p2].Contains(river)) continue;
number ev;
if (DerivedSetup.SuitReduce)
{
// Map all of our cards (community and pockets) using the flop map
// (because we are using a suit reduced data structure).
var f = Flop.Flops[flop];
int _flop = Flop.IndexOf(f.Representative);
int _turn = f.CardMap[turn];
int _river = f.CardMap[river];
int _p1 = f.PocketMap[p1];
int _p2 = f.PocketMap[p2];
ev = root.Simulate(S1, S2, _p1, _p2, _flop, _turn, _river);
}
else
{
ev = root.Simulate(S1, S2, p1, p2, flop, turn, river);
}
TotalMass += 1;
EV += ev;
PocketTotalMass += 1;
PocketEV += ev;
}
}
}
}
//Tools.LogPrint(" EV(p1 = {0}) = {1}", p1, PocketEV / PocketTotalMass);
//Tools.LogPrint(" EV(p1 = {0}) = {1}", Pocket.Pockets[p1], PocketEV / PocketTotalMass);
}
Assert.IsNum(EV / TotalMass);
return EV / TotalMass;
}
public Node <INode> GetNode(string nodeName)
{
switch (nodeName)
{
case Add.NAME:
INode nodeAdd = new Add() as INode;
return(new Node <INode> (nodeAdd));
case Condition.NAME:
INode nodeCondition = new Condition() as INode;
return(new Node <INode> (nodeCondition));
case Multiply.NAME:
INode nodeMultiply = new Multiply() as INode;
return(new Node <INode> (nodeMultiply));
case Note.NAME:
INode note = new Note() as INode;
return(new Node <INode> (note));
case Print.NAME:
INode NodePrint = new Print() as INode;
return(new Node <INode> (NodePrint));
case Remove.NAME:
INode NodeRemove = new Remove() as INode;
return(new Node <INode> (NodeRemove));
case Switch.NAME:
INode NodeSwitch = new Switch() as INode;
return(new Node <INode> (NodeSwitch));
case Value.NAME:
INode nodeValue = new Value() as INode;
return(new Node <INode> (nodeValue));
case Var.NAME:
INode nodeVar = new Var() as INode;
return(new Node <INode> (nodeVar));
case Word.NAME:
INode nodeWord = new Word() as INode;
return(new Node <INode> (nodeWord));
case Sender.NAME:
INode nodeSender = new Sender() as INode;
return(new Node <INode> (nodeSender));
case Receiver.NAME:
INode nodeReceiver = new Receiver() as INode;
return(new Node <INode>(nodeReceiver));
case CodeVar.NAME:
INode nodeGetVar = new CodeVar() as INode;
return(new Node <INode>(nodeGetVar));
case TeleportIn.NAME:
INode nodeTeleportIn = new TeleportIn() as INode;
return(new Node <INode>(nodeTeleportIn));
case TeleportOut.NAME:
INode nodeTeleportOut = new TeleportOut() as INode;
return(new Node <INode>(nodeTeleportOut));
default:
return(null);
}
}
public TextLoaderPipelineStep(Var <IDataView> data)
{
Data = data;
Model = null;
}
public ReadNode(Var n)
{
node = n;
}
static void Main(string[] args)
{
#region Látványosságokat és csúcsokat létrehoz
var budaiVar = new Var("Budai vár", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var budaivarCsucs = new Csucs(budaiVar);
var matyasTemplom = new Templom("Mátyás Templom", 1800, Latvanyossagok.ErdekessegiSzint.NagyonJó);
var matyasTemplomCsucs = new Csucs(matyasTemplom);
var halaszBastya = new Kilato("Halászbástya", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var halaszBastyaCsucs = new Csucs(halaszBastya);
var citadella = new Kilato("Citadella", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var citadellaCsucs = new Csucs(citadella);
var parlament = new Egyeb("Parlament", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var parlamentCsucs = new Csucs(parlament);
var gellertFurdo = new Furdo("Gellért fürdő", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var gellertFurdoCsucs = new Csucs(gellertFurdo);
var margitSziget = new Egyeb("Margit Sziget", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var margitSzigetCsucs = new Csucs(margitSziget);
var budapestEye = new Kilato("Budapest Eye", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var budapestEyeCsucs = new Csucs(budapestEye);
var bazilika = new Templom("Szent István Bazilika", 1000, Latvanyossagok.ErdekessegiSzint.NagyonJó);
var bazilikaCsucs = new Csucs(bazilika);
var zsinagoga = new Templom("Dohány utcai Zsinagóga", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var zsinagogaCsucs = new Csucs(zsinagoga);
var hosokTere = new Egyeb("Hősök tere", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var hosokTereCsucs = new Csucs(hosokTere);
var vajdaHunyadVara = new Var("Vajdahunyad vára", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var vajdaHunyadVaraCsucs = new Csucs(vajdaHunyadVara);
var szechenyiFurdo = new Furdo("Széchenyi fürdő", 4500, Latvanyossagok.ErdekessegiSzint.EgészJó);
var szechenyiFurdoCsucs = new Csucs(szechenyiFurdo);
//Várak
budaiVar.HasonloLatvanyossagHozzaad(vajdaHunyadVara);
vajdaHunyadVara.HasonloLatvanyossagHozzaad(budaiVar);
//Egyéb
parlament.HasonloLatvanyossagHozzaad(margitSziget);
parlament.HasonloLatvanyossagHozzaad(hosokTere);
margitSziget.HasonloLatvanyossagHozzaad(parlament);
margitSziget.HasonloLatvanyossagHozzaad(hosokTere);
hosokTere.HasonloLatvanyossagHozzaad(parlament);
hosokTere.HasonloLatvanyossagHozzaad(margitSziget);
//Fürdők
gellertFurdo.HasonloLatvanyossagHozzaad(szechenyiFurdo);
szechenyiFurdo.HasonloLatvanyossagHozzaad(gellertFurdo);
//Kilátók
halaszBastya.HasonloLatvanyossagHozzaad(citadella);
halaszBastya.HasonloLatvanyossagHozzaad(budapestEye);
citadella.HasonloLatvanyossagHozzaad(halaszBastya);
citadella.HasonloLatvanyossagHozzaad(budapestEye);
budapestEye.HasonloLatvanyossagHozzaad(halaszBastya);
budapestEye.HasonloLatvanyossagHozzaad(citadella);
//Templomok
matyasTemplom.HasonloLatvanyossagHozzaad(bazilika);
matyasTemplom.HasonloLatvanyossagHozzaad(zsinagoga);
bazilika.HasonloLatvanyossagHozzaad(matyasTemplom);
bazilika.HasonloLatvanyossagHozzaad(zsinagoga);
zsinagoga.HasonloLatvanyossagHozzaad(matyasTemplom);
zsinagoga.HasonloLatvanyossagHozzaad(bazilika);
#endregion
#region gráfok
#region gráf létrehozása, csúcsok felvétele
Graf graf = new Graf();
graf.UjCsucs(budaivarCsucs);
graf.UjCsucs(matyasTemplomCsucs);
graf.UjCsucs(halaszBastyaCsucs);
graf.UjCsucs(citadellaCsucs);
graf.UjCsucs(parlamentCsucs);
graf.UjCsucs(gellertFurdoCsucs);
graf.UjCsucs(margitSzigetCsucs);
graf.UjCsucs(budapestEyeCsucs);
graf.UjCsucs(bazilikaCsucs);
graf.UjCsucs(zsinagogaCsucs);
graf.UjCsucs(hosokTereCsucs);
graf.UjCsucs(vajdaHunyadVaraCsucs);
graf.UjCsucs(szechenyiFurdoCsucs);
#endregion
#region Élek hozzáadása
graf.ElHozzaad(new El(budaivarCsucs, matyasTemplomCsucs, 1));
graf.ElHozzaad(new El(budaivarCsucs, halaszBastyaCsucs, 1));
graf.ElHozzaad(new El(matyasTemplomCsucs, parlamentCsucs, 3));
graf.ElHozzaad(new El(halaszBastyaCsucs, matyasTemplomCsucs, 1));
// graf.ElHozzaad(new El(citadellaCsucs, budaivarCsucs, 5));
// graf.ElHozzaad(new El(parlamentCsucs, gellertFurdoCsucs, 3));
graf.ElHozzaad(new El(parlamentCsucs, margitSzigetCsucs, 5));
graf.ElHozzaad(new El(parlamentCsucs, budapestEyeCsucs, 2));
graf.ElHozzaad(new El(parlamentCsucs, bazilikaCsucs, 2));
graf.ElHozzaad(new El(parlamentCsucs, zsinagogaCsucs, 2));
graf.ElHozzaad(new El(parlamentCsucs, hosokTereCsucs, 4));
// graf.ElHozzaad(new El(parlamentCsucs, citadellaCsucs, 5));
graf.ElHozzaad(new El(gellertFurdoCsucs, parlamentCsucs, 3));
graf.ElHozzaad(new El(margitSzigetCsucs, budapestEyeCsucs, 3));
graf.ElHozzaad(new El(budapestEyeCsucs, bazilikaCsucs, 1));
// graf.ElHozzaad(new El(bazilikaCsucs, parlamentCsucs, 2));
graf.ElHozzaad(new El(bazilikaCsucs, zsinagogaCsucs, 2));
graf.ElHozzaad(new El(zsinagogaCsucs, hosokTereCsucs, 4));
graf.ElHozzaad(new El(hosokTereCsucs, vajdaHunyadVaraCsucs, 1));
graf.ElHozzaad(new El(vajdaHunyadVaraCsucs, szechenyiFurdoCsucs, 1));
// graf.ElHozzaad(new El(szechenyiFurdoCsucs, parlamentCsucs, 5));
#endregion
#endregion
Console.WriteLine("------------------ FŐ PROGRAM -------");
Turista turista;
string nev;
Console.WriteLine("Kérlek, add meg a neved!");
nev = Console.ReadLine();
turista = new Turista(nev);
while (true)
{
Console.Clear();
GrafCsucsokFelhasznaloValasztashoz(graf);
Console.WriteLine("Kedves {0}! Kérlek, válassz kiindulási pontot!\n", turista.Nev);
int indulas = Convert.ToInt16(Console.ReadLine());
Console.WriteLine(graf.Csucsok[indulas].Latvanyossag.Nev);
Console.WriteLine("Kedves {0}! Kérlek, válassz célpontot!\n", turista.Nev);
int erkezes = Convert.ToInt16(Console.ReadLine());
Console.WriteLine(graf.Csucsok[erkezes].Latvanyossag.Nev);
Console.WriteLine();
// Dijkstra.DijkstraAlgo(GrafToMatrix(graf), 0, 8, graf);
//TombKiir(GrafToMatrix(graf));
Map terkep = new Map();
List <Csucs> utvonal = Utkereses.LegrovidebbUt(terkep, graf.Csucsok[indulas], graf.Csucsok[erkezes], graf);
turista.Utvonal = utvonal;
turista.Utvonal.Add(budaivarCsucs);
turista.Utvonal.Add(parlamentCsucs);
foreach (Csucs latvany in turista.Utvonal)
{
Console.Write(latvany.Latvanyossag.Nev + " => ");
}
Console.WriteLine("VEGE");
Console.ReadLine();
}
}
/**
* Sets the var.
*/
public Var setVar(Var var)
{
_var = var;
return(var);
}
public override bool Walk(Var node)
{
AddNode(node); return(true);
}
public Expr Parse(ParserContext pcon, object frm)
{
ISeq form = (ISeq)frm;
// form => (let [var1 val1 var2 val2 ... ] body ... )
// or (loop [var1 val1 var2 val2 ... ] body ... )
bool isLoop = RT.first(form).Equals(Compiler.LoopSym);
IPersistentVector bindings = RT.second(form) as IPersistentVector;
if (bindings == null)
{
throw new ParseException("Bad binding form, expected vector");
}
if ((bindings.count() % 2) != 0)
{
throw new ParseException("Bad binding form, expected matched symbol/value pairs.");
}
ISeq body = RT.next(RT.next(form));
if (pcon.Rhc == RHC.Eval ||
(pcon.Rhc == RHC.Expression && isLoop))
{
return(Compiler.Analyze(pcon, RT.list(RT.list(Compiler.FnOnceSym, PersistentVector.EMPTY, form)), "let__" + RT.nextID()));
}
ObjMethod method = (ObjMethod)Compiler.MethodVar.deref();
IPersistentMap backupMethodLocals = method.Locals;
IPersistentMap backupMethodIndexLocals = method.IndexLocals;
IPersistentVector recurMismatches = PersistentVector.EMPTY;
for (int i = 0; i < bindings.count() / 2; i++)
{
recurMismatches = recurMismatches.cons(false);
}
// may repeat once for each binding with a mismatch, return breaks
while (true)
{
IPersistentMap dynamicBindings = RT.map(
Compiler.LocalEnvVar, Compiler.LocalEnvVar.deref(),
Compiler.NextLocalNumVar, Compiler.NextLocalNumVar.deref());
method.Locals = backupMethodLocals;
method.IndexLocals = backupMethodIndexLocals;
if (isLoop)
{
dynamicBindings = dynamicBindings.assoc(Compiler.LoopLocalsVar, null);
}
try
{
Var.pushThreadBindings(dynamicBindings);
IPersistentVector bindingInits = PersistentVector.EMPTY;
IPersistentVector loopLocals = PersistentVector.EMPTY;
for (int i = 0; i < bindings.count(); i += 2)
{
if (!(bindings.nth(i) is Symbol))
{
throw new ParseException("Bad binding form, expected symbol, got " + bindings.nth(i));
}
Symbol sym = (Symbol)bindings.nth(i);
if (sym.Namespace != null)
{
throw new ParseException("Can't let qualified name: " + sym);
}
Expr init = Compiler.Analyze(pcon.SetRhc(RHC.Expression).SetAssign(false), bindings.nth(i + 1), sym.Name);
if (isLoop)
{
if (recurMismatches != null && RT.booleanCast(recurMismatches.nth(i / 2)))
{
HostArg ha = new HostArg(HostArg.ParameterType.Standard, init, null);
List <HostArg> has = new List <HostArg>(1);
has.Add(ha);
init = new StaticMethodExpr("", PersistentArrayMap.EMPTY, null, typeof(RT), "box", null, has);
if (RT.booleanCast(RT.WarnOnReflectionVar.deref()))
{
RT.errPrintWriter().WriteLine("Auto-boxing loop arg: " + sym);
}
}
else if (Compiler.MaybePrimitiveType(init) == typeof(int))
{
List <HostArg> args = new List <HostArg>();
args.Add(new HostArg(HostArg.ParameterType.Standard, init, null));
init = new StaticMethodExpr("", null, null, typeof(RT), "longCast", null, args);
}
else if (Compiler.MaybePrimitiveType(init) == typeof(float))
{
List <HostArg> args = new List <HostArg>();
args.Add(new HostArg(HostArg.ParameterType.Standard, init, null));
init = new StaticMethodExpr("", null, null, typeof(RT), "doubleCast", null, args);
}
}
// Sequential enhancement of env (like Lisp let*)
LocalBinding b = Compiler.RegisterLocal(sym, Compiler.TagOf(sym), init, false);
BindingInit bi = new BindingInit(b, init);
bindingInits = bindingInits.cons(bi);
if (isLoop)
{
loopLocals = loopLocals.cons(b);
}
}
if (isLoop)
{
Compiler.LoopLocalsVar.set(loopLocals);
}
Expr bodyExpr;
bool moreMismatches = false;
try
{
if (isLoop)
{
// stuff with clear paths,
Var.pushThreadBindings(RT.map(Compiler.NoRecurVar, null));
}
bodyExpr = new BodyExpr.Parser().Parse(isLoop ? pcon.SetRhc(RHC.Return) : pcon, body);
}
finally
{
if (isLoop)
{
Var.popThreadBindings();
for (int i = 0; i < loopLocals.count(); i++)
{
LocalBinding lb = (LocalBinding)loopLocals.nth(i);
if (lb.RecurMismatch)
{
recurMismatches = (IPersistentVector)recurMismatches.assoc(i, true);
moreMismatches = true;
}
}
}
}
if (!moreMismatches)
{
return(new LetExpr(bindingInits, bodyExpr, isLoop));
}
}
finally
{
Var.popThreadBindings();
}
}
}
/// <summary> Tcl_ForeachObjCmd -> ForeachCmd.cmdProc
///
/// This procedure is invoked to process the "foreach" Tcl command.
/// See the user documentation for details on what it does.
///
/// </summary>
/// <param name="interp">the current interpreter.
/// </param>
/// <param name="objv">command arguments.
/// </param>
/// <exception cref=""> TclException if script causes error.
/// </exception>
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] objv)
{
if (objv.Length < 4 || (objv.Length % 2) != 0)
{
throw new TclNumArgsException(interp, 1, objv, "varList list ?varList list ...? command");
}
// foreach {n1 n2} {1 2 3 4} {n3} {1 2} {puts $n1-$n2-$n3}
// name[0] = {n1 n2} value[0] = {1 2 3 4}
// name[1] = {n3} value[0] = {1 2}
TclObject[] name = new TclObject[(objv.Length - 2) / 2];
TclObject[] value = new TclObject[(objv.Length - 2) / 2];
int c, i, j, base_;
int maxIter = 0;
TclObject command = objv[objv.Length - 1];
bool done = false;
for (i = 0; i < objv.Length - 2; i += 2)
{
int x = i / 2;
name[x] = objv[i + 1];
value[x] = objv[i + 2];
int nSize = TclList.getLength(interp, name[x]);
int vSize = TclList.getLength(interp, value[x]);
if (nSize == 0)
{
throw new TclException(interp, "foreach varlist is empty");
}
int iter = (vSize + nSize - 1) / nSize;
if (maxIter < iter)
{
maxIter = iter;
}
}
for (c = 0; !done && c < maxIter; c++)
{
// Set up the variables
for (i = 0; i < objv.Length - 2; i += 2)
{
int x = i / 2;
int nSize = TclList.getLength(interp, name[x]);
base_ = nSize * c;
for (j = 0; j < nSize; j++)
{
// Test and see if the name variable is an array.
Var[] result = Var.LookupVar(interp, name[x].ToString(), null, 0, null, false, false);
Var var = null;
if (result != null)
{
if (result[1] != null)
{
var = result[1];
}
else
{
var = result[0];
}
}
try
{
if (base_ + j >= TclList.getLength(interp, value[x]))
{
interp.SetVar(TclList.index(interp, name[x], j), TclString.NewInstance(""), 0);
}
else
{
interp.SetVar(TclList.index(interp, name[x], j), TclList.index(interp, value[x], base_ + j), 0);
}
}
catch (TclException e)
{
throw new TclException(interp, "couldn't set loop variable: \"" + TclList.index(interp, name[x], j) + "\"");
}
}
}
// Execute the script
try
{
interp.Eval(command, 0);
}
catch (TclException e)
{
switch (e.GetCompletionCode())
{
case TCL.CompletionCode.BREAK:
done = true;
break;
case TCL.CompletionCode.CONTINUE:
continue;
case TCL.CompletionCode.ERROR:
interp.AddErrorInfo("\n (\"foreach\" body line " + interp._errorLine + ")");
throw;
default:
throw;
}
}
}
interp.ResetResult();
return(TCL.CompletionCode.RETURN);
}
public virtual void Visit(Var node)
{
if (node != null)
{
AcceptChildren(node);
}
}
public TCL.CompletionCode CmdProc(Interp interp, TclObject[] objv)
{
string varName;
int tail, cp;
Var var, array;
TclObject varValue;
int i;
for (i = 1; i < objv.Length; i = i + 2)
{
// Look up each variable in the current namespace context, creating
// it if necessary.
varName = objv[i].ToString();
Var[] result = Var.LookupVar(interp, varName, null, (TCL.VarFlag.NAMESPACE_ONLY | TCL.VarFlag.LEAVE_ERR_MSG), "define", true, false);
if (result == null)
{
// FIXME:
throw new TclException(interp, "");
}
var = result[0];
array = result[1];
// Mark the variable as a namespace variable and increment its
// reference count so that it will persist until its namespace is
// destroyed or until the variable is unset.
if ((var.Flags & VarFlags.NAMESPACE_VAR) == 0)
{
var.Flags |= VarFlags.NAMESPACE_VAR;
var.RefCount++;
}
// If a value was specified, set the variable to that value.
// Otherwise, if the variable is new, leave it undefined.
// (If the variable already exists and no value was specified,
// leave its value unchanged; just create the local link if
// we're in a Tcl procedure).
if (i + 1 < objv.Length)
{
// a value was specified
varValue = Var.SetVar(interp, objv[i], null, objv[i + 1], (TCL.VarFlag.NAMESPACE_ONLY | TCL.VarFlag.LEAVE_ERR_MSG));
if (varValue == null)
{
// FIXME:
throw new TclException(interp, "");
}
}
// If we are executing inside a Tcl procedure, create a local
// variable linked to the new namespace variable "varName".
if ((interp.VarFrame != null) && interp.VarFrame.IsProcCallFrame)
{
// varName might have a scope qualifier, but the name for the
// local "link" variable must be the simple name at the tail.
//
// Locate tail in one pass: drop any prefix after two *or more*
// consecutive ":" characters).
int len = varName.Length;
for (tail = cp = 0; cp < len;)
{
if (varName[cp++] == ':')
{
while ((cp < len) && (varName[cp++] == ':'))
{
tail = cp;
}
}
}
// Create a local link "tail" to the variable "varName" in the
// current namespace.
Var.makeUpvar(interp, null, varName, null, TCL.VarFlag.NAMESPACE_ONLY, varName.Substring(tail), 0);
}
}
return(TCL.CompletionCode.RETURN);
}
public Term random_double_0()
{
Term result = new Var();
unify(result, new alice.tuprolog.Double(_random.NextDouble()));
return result;
}
public Message ApplyAndDisplay(ArcadeUser user)
{
ImmutableColor color = ImmutableColor.GammaGreen;
string type = IsSuccess ? "+" : "-";
long value = IsSuccess ? Reward : Wager;
user.AddToVar(TickStats.TotalBet, Wager);
user.AddToVar(TickStats.TimesPlayed);
user.ChipBalance -= Wager;
switch (Flag)
{
case TickResultFlag.Exact:
case TickResultFlag.Win:
user.SetVar(TickStats.CurrentLossStreak, 0);
user.AddToVar(TickStats.TimesWon);
user.AddToVar(TickStats.TotalWon, Reward);
if (ExpectedTick == ActualTick)
{
user.AddToVar(TickStats.TimesWonExact);
}
user.AddToVar(TickStats.CurrentWinStreak);
user.AddToVar(TickStats.CurrentWinAmount, Reward);
Var.SetIfGreater(user, TickStats.LongestWin, TickStats.CurrentWinStreak);
Var.SetIfGreater(user, TickStats.LargestWin, TickStats.CurrentWinAmount);
Var.SetIfGreater(user, TickStats.LargestWinSingle, Reward);
break;
case TickResultFlag.Lose:
Var.Clear(user, TickStats.CurrentWinStreak, TickStats.CurrentWinAmount);
user.AddToVar(TickStats.TimesLost);
user.AddToVar(TickStats.CurrentLossStreak);
break;
default:
throw new ArgumentOutOfRangeException(nameof(Flag));
}
if (IsSuccess)
{
user.ChipBalance += CurrencyHelper.BoostValue(user, Reward, BoostType.Chips);
}
string header = $"**{type} 🧩 {value:##,0}**";
string content = Replies.GetReply(Flag, user, this);
//GetQuote(ExpectedTick, ActualTick, Multiplier, Reward, IsSuccess);
var embedder = new Embedder
{
Header = header,
Color = color
};
var builder = new MessageBuilder();
builder.WithEmbedder(embedder)
.WithContent(content);
return(builder.Build());
}
internal Expression GenVarValue(GenContext context, Var v)
{
int i = (int)_vars.valAt(v);
if (_fnMode == Ast.FnMode.Full && !v.isDynamic())
{
//Type ft = _varCallsites.contains(v) ? typeof(IFn) : typeof(Object);
//return Expression.Field(null, _cachedVarFields[i]);
return Expression.Call(GenConstant(context, i, v), Compiler.Method_Var_getRawRoot);
}
else
{
return Expression.Call(GenConstant(context, i, v), Compiler.Method_Var_get);
}
}
public override void WriteTo(CodeWriter writer)
{
if (Mask)
{
writer.AddCommentLine(CommentOnStart);
using (writer.NewBlock())
{
Block.WriteTo(writer);
}
writer.AddCommentLine(CommentOnEnd);
return;
}
var hasVar = Var != null;
var varPrefix = C.AllocTempVar();
var varForIndex = $"{varPrefix}_index";
var varForEnd = $"{varPrefix}_end";
var varForStep = $"{varPrefix}_step";
var varForIsNegStep = $"{varPrefix}_isNegStep";
var typeName = $"decltype({varForIndex})";
CppTypeName expectedType = null;
writer.NewLine();
if (hasVar)
{
expectedType = Var.GetResultType();
typeName = expectedType.ToString();
writer.Write(typeName);
writer.Write(" ");
}
else
{
writer.Write("auto ");
}
writer.Write(varForIndex);
writer.Write(" = ");
Start.WriteToWithCast(writer, expectedType);
writer.Write(";");
writer.NewLine();
writer.Write(typeName);
writer.Write(" ");
writer.Write(varForEnd);
writer.Write(" = ");
End.WriteToWithCast(writer, expectedType);
writer.Write(";");
writer.NewLine();
writer.Write(typeName);
writer.Write(" ");
writer.Write(varForStep);
writer.Write(" = ");
Step.WriteToWithCast(writer, expectedType);
writer.Write(";");
writer.NewLine();
writer.Write("bool ");
writer.Write(varForIsNegStep);
writer.Write(" = ");
writer.Write(varForStep);
writer.Write(" <= 0;");
writer.NewLine();
writer.Write("for (");
if (hasVar)
{
C.WriteLetExpression(writer, Var, () =>
{
writer.Write(varForIndex);
});
}
writer.Write("; ");
writer.Write(varForIsNegStep);
writer.Write(" ? ");
writer.Write(varForIndex);
writer.Write(" >= ");
writer.Write(varForEnd);
writer.Write(" : ");
writer.Write(varForIndex);
writer.Write(" <= ");
writer.Write(varForEnd);
writer.Write("; ");
if (hasVar)
{
C.WriteLetExpression(writer, Var, () =>
{
writer.Write(varForIndex);
writer.Write(" += ");
writer.Write(varForStep);
});
}
else
{
writer.Write(varForIndex);
writer.Write(" += ");
writer.Write(varForStep);
}
writer.Write(")");
using (writer.NewBlock())
{
Block.WriteTo(writer);
}
}
internal void EmitVarValue(CljILGen ilg, Var v)
{
int i = (int)Vars.valAt(v);
if ( !v.isDynamic() )
{
EmitConstant(ilg, i, v);
ilg.Emit(OpCodes.Call, Compiler.Method_Var_getRawRoot);
}
else
{
EmitConstant(ilg, i, v);
ilg.Emit(OpCodes.Call, Compiler.Method_Var_get); // or just Method_Var_get??
}
}
public ScorerPipelineStep(Var <IDataView> data, Var <TransformModel> model)
{
Data = data;
Model = model;
}
public override void VisitVar(Var var)
{
// Create the array
IL.Emit(OpCodes.Ldc_I4, var.Variables.Length);
IL.Emit(OpCodes.Newarr, typeof(string));
IL.Emit(OpCodes.Stloc, Vars);
// Set each index of the array to a string
// arr[i] = var[i]
for (int i = 0; i < var.Variables.Length; i++)
{
IL.Emit(OpCodes.Ldloc, Vars);
IL.Emit(OpCodes.Ldc_I4, i);
IL.Emit(OpCodes.Ldstr, var.Variables[i]);
IL.Emit(OpCodes.Stelem, typeof(string));
}
// Call ExecutionContext.LocalVars(string[] vars)
IL.Emit(OpCodes.Ldloc, Vars);
IL.Emit(OpCodes.Call, typeof(ExecutionContext).GetMethod("LocalVars"));
}
/// <summary>
/// Creates an expression object from <see cref="FunctionToken"/>.
/// </summary>
/// <param name="token">The function token.</param>
/// <returns>An expression.</returns>
protected virtual IExpression CreateFunction(FunctionToken token)
{
IExpression exp;
switch (token.Function)
{
case Functions.Add:
exp = new Add(); break;
case Functions.Sub:
exp = new Sub(); break;
case Functions.Mul:
exp = new Mul(); break;
case Functions.Div:
exp = new Div(); break;
case Functions.Pow:
exp = new Pow(); break;
case Functions.Absolute:
exp = new Abs(); break;
case Functions.Sine:
exp = new Sin(); break;
case Functions.Cosine:
exp = new Cos(); break;
case Functions.Tangent:
exp = new Tan(); break;
case Functions.Cotangent:
exp = new Cot(); break;
case Functions.Secant:
exp = new Sec(); break;
case Functions.Cosecant:
exp = new Csc(); break;
case Functions.Arcsine:
exp = new Arcsin(); break;
case Functions.Arccosine:
exp = new Arccos(); break;
case Functions.Arctangent:
exp = new Arctan(); break;
case Functions.Arccotangent:
exp = new Arccot(); break;
case Functions.Arcsecant:
exp = new Arcsec(); break;
case Functions.Arccosecant:
exp = new Arccsc(); break;
case Functions.Sqrt:
exp = new Sqrt(); break;
case Functions.Root:
exp = new Root(); break;
case Functions.Ln:
exp = new Ln(); break;
case Functions.Lg:
exp = new Lg(); break;
case Functions.Lb:
exp = new Lb(); break;
case Functions.Log:
exp = new Log(); break;
case Functions.Sineh:
exp = new Sinh(); break;
case Functions.Cosineh:
exp = new Cosh(); break;
case Functions.Tangenth:
exp = new Tanh(); break;
case Functions.Cotangenth:
exp = new Coth(); break;
case Functions.Secanth:
exp = new Sech(); break;
case Functions.Cosecanth:
exp = new Csch(); break;
case Functions.Arsineh:
exp = new Arsinh(); break;
case Functions.Arcosineh:
exp = new Arcosh(); break;
case Functions.Artangenth:
exp = new Artanh(); break;
case Functions.Arcotangenth:
exp = new Arcoth(); break;
case Functions.Arsecanth:
exp = new Arsech(); break;
case Functions.Arcosecanth:
exp = new Arcsch(); break;
case Functions.Exp:
exp = new Exp(); break;
case Functions.GCD:
exp = new GCD(); break;
case Functions.LCM:
exp = new LCM(); break;
case Functions.Factorial:
exp = new Fact(); break;
case Functions.Sum:
exp = new Sum(); break;
case Functions.Product:
exp = new Product(); break;
case Functions.Round:
exp = new Round(); break;
case Functions.Floor:
exp = new Floor(); break;
case Functions.Ceil:
exp = new Ceil(); break;
case Functions.Derivative:
exp = new Derivative(); break;
case Functions.Simplify:
exp = new Simplify(); break;
case Functions.Del:
exp = new Del(); break;
case Functions.Define:
exp = new Define(); break;
case Functions.Vector:
exp = new Vector(); break;
case Functions.Matrix:
exp = new Matrix(); break;
case Functions.Transpose:
exp = new Transpose(); break;
case Functions.Determinant:
exp = new Determinant(); break;
case Functions.Inverse:
exp = new Inverse(); break;
case Functions.If:
exp = new If(); break;
case Functions.For:
exp = new For(); break;
case Functions.While:
exp = new While(); break;
case Functions.Undefine:
exp = new Undefine(); break;
case Functions.Im:
exp = new Im(); break;
case Functions.Re:
exp = new Re(); break;
case Functions.Phase:
exp = new Phase(); break;
case Functions.Conjugate:
exp = new Conjugate(); break;
case Functions.Reciprocal:
exp = new Reciprocal(); break;
case Functions.Min:
exp = new Min(); break;
case Functions.Max:
exp = new Max(); break;
case Functions.Avg:
exp = new Avg(); break;
case Functions.Count:
exp = new Count(); break;
case Functions.Var:
exp = new Var(); break;
case Functions.Varp:
exp = new Varp(); break;
case Functions.Stdev:
exp = new Stdev(); break;
case Functions.Stdevp:
exp = new Stdevp(); break;
default:
exp = null; break;
}
var diff = exp as DifferentParametersExpression;
if (diff != null)
{
diff.ParametersCount = token.CountOfParams;
}
return(exp);
}
public VarExpr(Var var, Symbol tag)
{
_var = var;
_tag = tag ?? var.Tag;
}
private void calcDesignStats(Design design, StaticsDB statics)
{
var shipVars = DesignPoweredVars(design.Hull, design.Reactor, design.SpecialEquipment, statics);
var hullVars = new Var(AComponentType.LevelKey, design.Hull.Level).Get;
var armorVars = new Var(AComponentType.LevelKey, design.Armor.Level).Get;
var thrusterVars = new Var(AComponentType.LevelKey, design.Thrusters.Level).Get;
var sensorVars = new Var(AComponentType.LevelKey, design.Sensors.Level).Get;
shipVars.And("armorFactor", design.Armor.TypeInfo.ArmorFactor.Evaluate(armorVars)).
And("baseEvasion", design.Thrusters.TypeInfo.Evasion.Evaluate(thrusterVars)).
And("thrust", design.Thrusters.TypeInfo.Speed.Evaluate(thrusterVars)).
And("sensor", design.Sensors.TypeInfo.Detection.Evaluate(sensorVars));
double galaxySpeed = 0;
if (design.IsDrive != null)
{
shipVars[AComponentType.LevelKey] = design.IsDrive.Level;
galaxySpeed = design.IsDrive.TypeInfo.Speed.Evaluate(shipVars.Get);
}
var buildings = new Dictionary <string, double>();
foreach (var colonyBuilding in statics.ShipFormulas.ColonizerBuildings)
{
double amount = colonyBuilding.Value.Evaluate(shipVars.Get);
if (amount > 0)
{
buildings.Add(colonyBuilding.Key, amount);
}
}
shipVars[AComponentType.LevelKey] = design.Armor.Level;
double baseArmorReduction = design.Armor.TypeInfo.Absorption.Evaluate(shipVars.Get);
double hullArFactor = design.Hull.TypeInfo.ArmorAbsorption.Evaluate(shipVars.Get);
double maxArmorReduction = design.Armor.TypeInfo.AbsorptionMax.Evaluate(shipVars.Get);
double shieldCloaking = 0;
double shieldJamming = 0;
double shieldHp = 0;
double shieldReduction = 0;
double shieldRegeneration = 0;
double shieldThickness = 0;
double shieldPower = 0;
if (design.Shield != null)
{
shipVars[AComponentType.LevelKey] = design.Shield.Level;
shipVars[AComponentType.SizeKey] = design.Hull.TypeInfo.Size.Evaluate(hullVars);
var hullShieldHp = design.Hull.TypeInfo.ShieldBase.Evaluate(hullVars);
shieldCloaking = design.Shield.TypeInfo.Cloaking.Evaluate(shipVars.Get) * hullShieldHp;
shieldJamming = design.Shield.TypeInfo.Jamming.Evaluate(shipVars.Get) * hullShieldHp;
shieldHp = design.Shield.TypeInfo.HpFactor.Evaluate(shipVars.Get) * hullShieldHp;
shieldReduction = design.Shield.TypeInfo.Reduction.Evaluate(shipVars.Get);
shieldRegeneration = design.Shield.TypeInfo.RegenerationFactor.Evaluate(shipVars.Get) * hullShieldHp;
shieldThickness = design.Shield.TypeInfo.Thickness.Evaluate(shipVars.Get);
shieldPower = design.Shield.TypeInfo.PowerUsage.Evaluate(shipVars.Get);
}
shipVars.And("shieldCloak", shieldCloaking);
shipVars.And("shieldJamming", shieldJamming);
var abilities = new List <AbilityStats>(design.MissionEquipment.SelectMany(
equip => equip.TypeInfo.Abilities.Select(
x => AbilityStatsFactory.Create(x, equip.Level, equip.Quantity, statics)
)
));
this.DesignStats[design] = new DesignStats(
design.Hull.TypeInfo.Size.Evaluate(hullVars),
galaxySpeed,
shipVars[ReactorType.TotalPowerKey],
statics.ShipFormulas.ScanRange.Evaluate(shipVars.Get),
statics.ShipFormulas.CombatSpeed.Evaluate(shipVars.Get),
shipVars[ReactorType.TotalPowerKey] - shieldPower,
abilities,
statics.ShipFormulas.ColonizerPopulation.Evaluate(shipVars.Get),
buildings,
statics.ShipFormulas.HitPoints.Evaluate(shipVars.Get),
shieldHp,
statics.ShipFormulas.Evasion.Evaluate(shipVars.Get),
Methods.Clamp(baseArmorReduction * hullArFactor, 0, maxArmorReduction),
shieldReduction,
shieldRegeneration,
shieldThickness,
statics.ShipFormulas.Detection.Evaluate(shipVars.Get),
statics.ShipFormulas.Cloaking.Evaluate(shipVars.Get),
statics.ShipFormulas.Jamming.Evaluate(shipVars.Get)
);
}
// <summary>
// Public constructor
// </summary>
// <param name="defingingGroupNode"> The GroupIntoOp node </param>
internal GroupAggregateVarInfo(Node defingingGroupNode, Var groupAggregateVar)
{
_definingGroupByNode = defingingGroupNode;
_groupAggregateVar = groupAggregateVar;
}
private double refitComponentCost <T>(Component <T> fromComponent, Component <T> toComponent, Func <T, Formula> costFormula, Var extraVars, ShipFormulaSet shipFormulas) where T : AComponentType
{
if (toComponent == null)
{
return(0);
}
if (extraVars == null)
{
extraVars = new Var();
}
var fullCost = costFormula(toComponent.TypeInfo).Evaluate(new Var(AComponentType.LevelKey, toComponent.Level).UnionWith(extraVars.Get).Get);
if (fromComponent == null || fromComponent.TypeInfo != toComponent.TypeInfo)
{
return(fullCost);
}
if (fromComponent.Level < toComponent.Level)
{
return(fullCost * shipFormulas.LevelRefitCost.Evaluate(new Var(AComponentType.LevelKey, toComponent.Level - fromComponent.Level).Get));
}
//refit from higher to lower or the same level is free
return(0);
}
public void ToStringTest2()
{
var sum = new Var(new[] { new Vector(new[] { new Number(1), new Number(2) }) }, 1);
Assert.Equal("var({1, 2})", sum.ToString());
}
private double refitComponentCost <T>(List <Component <T> > fromComponents, List <Component <T> > toComponents, Func <T, Formula> costFormula, Var extraVars, ShipFormulaSet shipFormulas) where T : AComponentType
{
double cost = 0;
var oldEquipment = fromComponents.
GroupBy(x => x).
ToDictionary(
x => x.Key.TypeInfo,
x => new Component <T>(x.Key.TypeInfo, x.Key.Level, x.Sum(y => y.Quantity))
);
foreach (var equip in toComponents)
{
var similarQuantity = 0;
var oldEquip = oldEquipment.ContainsKey(equip.TypeInfo) ? oldEquipment[equip.TypeInfo] : null;
if (oldEquip != null)
{
similarQuantity = Math.Min(oldEquip.Quantity, equip.Quantity);
if (similarQuantity < oldEquip.Quantity)
{
oldEquipment[equip.TypeInfo] = new Component <T>(equip.TypeInfo, oldEquip.Level, oldEquip.Quantity - similarQuantity);
}
else
{
oldEquipment.Remove(equip.TypeInfo);
}
}
cost += similarQuantity * refitComponentCost(oldEquip, equip, costFormula, extraVars, shipFormulas);
cost += (equip.Quantity - similarQuantity) * refitComponentCost(null, equip, costFormula, extraVars, shipFormulas);
}
return(cost);
}
public void VectorTest()
{
var exp = new Var(new[] { new Vector(new[] { new Number(2), new Number(4), new Number(9) }) }, 1);
var result = exp.Execute();
Assert.Equal(13.0, result);
}
public static CommonOutputs.MacroOutput <Output> CrossValidate(
IHostEnvironment env,
Arguments input,
EntryPointNode node)
{
env.CheckValue(input, nameof(input));
// This will be the final resulting list of nodes that is returned from the macro.
var subGraphNodes = new List <EntryPointNode>();
//the input transform model
VariableBinding transformModelVarName = null;
if (input.TransformModel != null)
{
transformModelVarName = node.GetInputVariable(nameof(input.TransformModel));
}
// Split the input data into folds.
var splitArgs = new CVSplit.Input();
splitArgs.NumFolds = input.NumFolds;
splitArgs.StratificationColumn = input.StratificationColumn;
var inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
var inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var inputData = node.GetInputVariable(nameof(splitArgs.Data));
ParameterBinding paramBinding = new SimpleParameterBinding(nameof(splitArgs.Data));
inputBindingMap.Add(nameof(splitArgs.Data), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputData);
var outputMap = new Dictionary <string, string>();
var splitOutputTrainData = new ArrayVar <IDataView>();
var splitOutputTestData = new ArrayVar <IDataView>();
outputMap.Add(nameof(CVSplit.Output.TrainData), splitOutputTrainData.VarName);
outputMap.Add(nameof(CVSplit.Output.TestData), splitOutputTestData.VarName);
var splitNode = EntryPointNode.Create(env, "Models.CrossValidatorDatasetSplitter", splitArgs,
node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(splitNode);
var predModelVars = new Var <PredictorModel> [input.NumFolds];
var inputTransformModelVars = new Var <PredictorModel> [input.NumFolds];
var warningsVars = new Var <IDataView> [input.NumFolds];
var overallMetricsVars = new Var <IDataView> [input.NumFolds];
var instanceMetricsVars = new Var <IDataView> [input.NumFolds];
var confusionMatrixVars = new Var <IDataView> [input.NumFolds];
// Instantiate the subgraph for each fold.
for (int k = 0; k < input.NumFolds; k++)
{
// Parse the nodes in input.Nodes into a temporary run context.
var context = new RunContext(env);
var graph = EntryPointNode.ValidateNodes(env, context, input.Nodes);
// Rename all the variables such that they don't conflict with the ones in the outer run context.
var mapping = new Dictionary <string, string>();
foreach (var entryPointNode in graph)
{
entryPointNode.RenameAllVariables(mapping);
}
// Instantiate a TrainTest entry point for this fold.
var args = new TrainTestMacro.Arguments
{
Nodes = new JArray(graph.Select(n => n.ToJson()).ToArray()),
TransformModel = null,
LabelColumn = input.LabelColumn,
GroupColumn = input.GroupColumn,
WeightColumn = input.WeightColumn,
NameColumn = input.NameColumn
};
if (transformModelVarName != null)
{
args.TransformModel = new Var <TransformModel> {
VarName = transformModelVarName.VariableName
}
}
;
args.Inputs.Data = new Var <IDataView>
{
VarName = mapping[input.Inputs.Data.VarName]
};
args.Outputs.PredictorModel = new Var <PredictorModel>
{
VarName = mapping[input.Outputs.PredictorModel.VarName]
};
// Set train/test trainer kind to match.
args.Kind = input.Kind;
// Set the input bindings for the TrainTest entry point.
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var trainingData = new SimpleParameterBinding(nameof(args.TrainingData));
inputBindingMap.Add(nameof(args.TrainingData), new List <ParameterBinding> {
trainingData
});
inputMap.Add(trainingData, new ArrayIndexVariableBinding(splitOutputTrainData.VarName, k));
var testingData = new SimpleParameterBinding(nameof(args.TestingData));
inputBindingMap.Add(nameof(args.TestingData), new List <ParameterBinding> {
testingData
});
inputMap.Add(testingData, new ArrayIndexVariableBinding(splitOutputTestData.VarName, k));
outputMap = new Dictionary <string, string>();
var transformModelVar = new Var <TransformModel>();
var predModelVar = new Var <PredictorModel>();
outputMap.Add(nameof(TrainTestMacro.Output.PredictorModel), predModelVar.VarName);
predModelVars[k] = predModelVar;
if (transformModelVarName != null && transformModelVarName.VariableName != null)
{
var combineModelsArgs = new ModelOperations.SimplePredictorModelInput();
inputBindingMap = new Dictionary <string, List <ParameterBinding> >();
inputMap = new Dictionary <ParameterBinding, VariableBinding>();
var inputTransformModel = new SimpleVariableBinding(transformModelVarName.VariableName);
var inputPredictorModel = new SimpleVariableBinding(predModelVar.VarName);
paramBinding = new SimpleParameterBinding(nameof(combineModelsArgs.TransformModel));
inputBindingMap.Add(nameof(combineModelsArgs.TransformModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputTransformModel);
paramBinding = new SimpleParameterBinding(nameof(combineModelsArgs.PredictorModel));
inputBindingMap.Add(nameof(combineModelsArgs.PredictorModel), new List <ParameterBinding>()
{
paramBinding
});
inputMap.Add(paramBinding, inputPredictorModel);
outputMap = new Dictionary <string, string>();
var combineNodeOutputPredictorModel = new Var <PredictorModel>();
predModelVars[k] = combineNodeOutputPredictorModel;
outputMap.Add(nameof(ModelOperations.PredictorModelOutput.PredictorModel), combineNodeOutputPredictorModel.VarName);
EntryPointNode combineNode = EntryPointNode.Create(env, "Transforms.TwoHeterogeneousModelCombiner", combineModelsArgs,
node.Context, inputBindingMap, inputMap, outputMap);
subGraphNodes.Add(combineNode);
}
var warningVar = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.Warnings), warningVar.VarName);
warningsVars[k] = warningVar;
var overallMetric = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.OverallMetrics), overallMetric.VarName);
overallMetricsVars[k] = overallMetric;
var instanceMetric = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.PerInstanceMetrics), instanceMetric.VarName);
instanceMetricsVars[k] = instanceMetric;
var confusionMatrix = new Var <IDataView>();
outputMap.Add(nameof(TrainTestMacro.Output.ConfusionMatrix), confusionMatrix.VarName);
confusionMatrixVars[k] = confusionMatrix;
const string trainTestEvaluatorMacroEntryPoint = "Models.TrainTestEvaluator";
subGraphNodes.Add(EntryPointNode.Create(env, trainTestEvaluatorMacroEntryPoint, args, node.Context, inputBindingMap, inputMap, outputMap));
}
// Convert the predictor models to an array of predictor models.
MacroUtils.ConvertIPredictorModelsToArray(env, node.Context, subGraphNodes, predModelVars, node.GetOutputVariableName(nameof(Output.PredictorModel)));
// Convert the warnings, overall, per instance and confusion matrix data views into an array.
var warningsArrayVar = new ArrayVar <IDataView>();
var overallArrayVar = new ArrayVar <IDataView>();
var instanceArrayVar = new ArrayVar <IDataView>();
ArrayVar <IDataView> confusionMatrixArrayVar = null;
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, warningsVars, warningsArrayVar.VarName);
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, overallMetricsVars, overallArrayVar.VarName);
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, instanceMetricsVars, instanceArrayVar.VarName);
if (input.Kind == MacroUtils.TrainerKinds.SignatureBinaryClassifierTrainer ||
input.Kind == MacroUtils.TrainerKinds.SignatureMulticlassClassificationTrainer)
{
confusionMatrixArrayVar = new ArrayVar <IDataView>();
MacroUtils.ConvertIdataViewsToArray(env, node.Context, subGraphNodes, confusionMatrixVars, confusionMatrixArrayVar.VarName);
}
var combineArgs = new CombineMetricsInput();
combineArgs.Kind = input.Kind;
combineArgs.LabelColumn = input.LabelColumn;
combineArgs.WeightColumn = input.WeightColumn;
combineArgs.GroupColumn = input.GroupColumn;
combineArgs.NameColumn = input.NameColumn;
// Set the input bindings for the CombineMetrics entry point.
var combineInputBindingMap = new Dictionary <string, List <ParameterBinding> >();
var combineInputMap = new Dictionary <ParameterBinding, VariableBinding>();
var warningsArray = new SimpleParameterBinding(nameof(combineArgs.Warnings));
combineInputBindingMap.Add(nameof(combineArgs.Warnings), new List <ParameterBinding> {
warningsArray
});
combineInputMap.Add(warningsArray, new SimpleVariableBinding(warningsArrayVar.VarName));
var overallArray = new SimpleParameterBinding(nameof(combineArgs.OverallMetrics));
combineInputBindingMap.Add(nameof(combineArgs.OverallMetrics), new List <ParameterBinding> {
overallArray
});
combineInputMap.Add(overallArray, new SimpleVariableBinding(overallArrayVar.VarName));
var combinePerInstArray = new SimpleParameterBinding(nameof(combineArgs.PerInstanceMetrics));
combineInputBindingMap.Add(nameof(combineArgs.PerInstanceMetrics), new List <ParameterBinding> {
combinePerInstArray
});
combineInputMap.Add(combinePerInstArray, new SimpleVariableBinding(instanceArrayVar.VarName));
if (confusionMatrixArrayVar != null)
{
var combineConfArray = new SimpleParameterBinding(nameof(combineArgs.ConfusionMatrix));
combineInputBindingMap.Add(nameof(combineArgs.ConfusionMatrix), new List <ParameterBinding> {
combineConfArray
});
combineInputMap.Add(combineConfArray, new SimpleVariableBinding(confusionMatrixArrayVar.VarName));
}
var combineOutputMap = new Dictionary <string, string>();
var combineWarningVar = new Var <IDataView>();
combineWarningVar.VarName = node.GetOutputVariableName(nameof(Output.Warnings));
combineOutputMap.Add(nameof(Output.Warnings), combineWarningVar.VarName);
var combineOverallMetric = new Var <IDataView>();
combineOverallMetric.VarName = node.GetOutputVariableName(nameof(Output.OverallMetrics));
combineOutputMap.Add(nameof(Output.OverallMetrics), combineOverallMetric.VarName);
var combineInstanceMetric = new Var <IDataView>();
combineInstanceMetric.VarName = node.GetOutputVariableName(nameof(Output.PerInstanceMetrics));
combineOutputMap.Add(nameof(Output.PerInstanceMetrics), combineInstanceMetric.VarName);
if (confusionMatrixArrayVar != null)
{
var combineConfusionMatrix = new Var <IDataView>();
combineConfusionMatrix.VarName = node.GetOutputVariableName(nameof(Output.ConfusionMatrix));
combineOutputMap.Add(nameof(TrainTestMacro.Output.ConfusionMatrix), combineConfusionMatrix.VarName);
}
var combineMetricsNode = EntryPointNode.Create(env, "Models.CrossValidationResultsCombiner",
combineArgs, node.Context, combineInputBindingMap, combineInputMap, combineOutputMap);
subGraphNodes.Add(combineMetricsNode);
return(new CommonOutputs.MacroOutput <Output>()
{
Nodes = subGraphNodes
});
}
public static number Simulation(Var S1, Var S2, PocketRoot root)
{
if (BetNode.SimultaneousBetting)
{
return _Simulation(S1, S2, root);
}
else
{
number EV1 = _Simulation(S1, S2, root);
number EV2 = -_Simulation(S2, S1, root);
number TotalEV = ((number).5) * (EV1 + EV2);
Tools.LogPrint("EV = {0} : {1} -> {2}", EV1, EV2, TotalEV);
return TotalEV;
}
}
public override void WriteTo(CodeWriter writer)
{
if (Mask)
{
writer.AddCommentLine(CommentOnStart);
using (writer.NewBlock())
{
Block.WriteTo(writer);
}
writer.AddCommentLine(CommentOnEnd);
return;
}
var hasVar = Var != null;
var varPrefix = C.AllocTempVar();
var varForCount = $"{varPrefix}_count";
var varForIndex = $"{varPrefix}_index";
var typeName = $"decltype({varForCount})";
writer.AddCommentLine(CommentOnStart);
writer.NewLine();
if (hasVar)
{
typeName = Var.GetResultType().ToString();
writer.Write(typeName);
writer.Write(" ");
}
else
{
writer.Write("auto ");
}
writer.Write(varForCount);
writer.Write(" = ");
Count.WriteTo(writer);
writer.Write(";");
writer.NewLine();
writer.Write(typeName);
writer.Write(" ");
writer.Write(varForIndex);
writer.Write(" = 1");
writer.Write(";");
writer.NewLine();
writer.Write("for (");
if (hasVar)
{
C.WriteLetExpression(writer, Var, () =>
{
writer.Write(varForIndex);
});
}
writer.Write("; ");
writer.Write(varForIndex);
writer.Write(" <= ");
writer.Write(varForCount);
writer.Write("; ");
if (hasVar)
{
C.WriteLetExpression(writer, Var, () =>
{
writer.Write("++");
writer.Write(varForIndex);
});
}
else
{
writer.Write(varForIndex);
writer.Write("++");
}
writer.Write(")");
using (writer.NewBlock())
{
Block.WriteTo(writer);
}
writer.AddCommentLine(CommentOnEnd);
}
public static Expr Parse(Var v, ISeq args, Symbol tag)
{
IPersistentCollection paramlists = (IPersistentCollection)RT.get(v.meta(), Compiler.ARGLISTS_KEY);
if (paramlists == null)
throw new InvalidOperationException("Can't call static fn with no arglists " + v);
IPersistentVector paramlist = null;
int argcount = RT.count(args);
bool variadic = false;
for (ISeq aseq = RT.seq(paramlists); aseq != null; aseq = aseq.next())
{
if (!(aseq.first() is IPersistentVector))
throw new InvalidOperationException("Expected vector arglist, had: " + aseq.first());
IPersistentVector alist = (IPersistentVector)aseq.first();
if (alist.count() > 1 && alist.nth(alist.count() - 2).Equals(Compiler._AMP_))
{
if (argcount >= alist.count() - 2)
{
paramlist = alist;
variadic = true;
}
}
else if (alist.count() == argcount)
{
paramlist = alist;
variadic = false;
break;
}
}
if (paramlist == null)
throw new ArgumentException(String.Format("Invalid arity - can't call: {0} with {1} args", v, argcount));
Type retClass = Compiler.TagType(Compiler.TagOf(paramlist));
List<Type> paramTypes = new List<Type>();
if (variadic)
{
for (int i = 0; i < paramlist.count() - 2; i++)
{
Type pt = Compiler.TagType(Compiler.TagOf(paramlist.nth(i)));
paramTypes.Add(pt);
}
paramTypes.Add(typeof(ISeq));
}
else
{
for (int i = 0; i < paramlist.count(); i++)
{
Type pt = Compiler.TagType(Compiler.TagOf(paramlist.nth(i)));
paramTypes.Add(pt);
}
}
string cname = v.Namespace.Name.Name.Replace('.', '/').Replace('-', '_') + "$" + Compiler.munge(v.sym.Name);
Type target = RT.classForName(cname); // not sure this will work.
IPersistentVector argv = PersistentVector.EMPTY;
for (ISeq s = RT.seq(args); s != null; s = s.next())
argv = argv.cons(Compiler.Analyze(new ParserContext(RHC.Expression), s.first()));
return new StaticInvokeExpr(target, retClass, paramTypes.ToArray(), variadic, argv, tag);
}
public void Parse()
{
var current = _reader.BaseStream.Position;
_reader.BaseStream.Seek(_offset, SeekOrigin.Begin);
bool parsing = true;
bool branched = false;
int branchBytes = 0;
while (parsing)
{
//now reader the instructions
var type = _reader.ReadByteAsEnum <InstructionType>();
var aligned = InstructionAlignment.IsAligned(type);
if (aligned)
{
var padding = _reader.Align(4);
if (padding > 0)
{
Items.Add(new Padding(padding));
if (branched)
{
branchBytes -= (int)padding;
if (branchBytes <= 0)
{
branched = false;
branchBytes = 0;
}
}
}
}
InstructionBase instruction = null;
List <Value> parameters = new List <Value>();
switch (type)
{
case InstructionType.ToNumber:
instruction = new ToNumber();
break;
case InstructionType.NextFrame:
instruction = new NextFrame();
break;
case InstructionType.Play:
instruction = new Play();
break;
case InstructionType.Stop:
instruction = new Stop();
break;
case InstructionType.Add:
instruction = new Add();
break;
case InstructionType.Subtract:
instruction = new Subtract();
break;
case InstructionType.Multiply:
instruction = new Multiply();
break;
case InstructionType.Divide:
instruction = new Divide();
break;
case InstructionType.Not:
instruction = new Not();
break;
case InstructionType.StringEquals:
instruction = new StringEquals();
break;
case InstructionType.Pop:
instruction = new Pop();
break;
case InstructionType.ToInteger:
instruction = new ToInteger();
break;
case InstructionType.GetVariable:
instruction = new GetVariable();
break;
case InstructionType.SetVariable:
instruction = new SetVariable();
break;
case InstructionType.StringConcat:
instruction = new StringConcat();
break;
case InstructionType.GetProperty:
instruction = new GetProperty();
break;
case InstructionType.SetProperty:
instruction = new SetProperty();
break;
case InstructionType.Trace:
instruction = new Trace();
break;
case InstructionType.Delete:
instruction = new Delete();
break;
case InstructionType.Delete2:
instruction = new Delete2();
break;
case InstructionType.DefineLocal:
instruction = new DefineLocal();
break;
case InstructionType.CallFunction:
instruction = new CallFunction();
break;
case InstructionType.Return:
instruction = new Return();
break;
case InstructionType.NewObject:
instruction = new NewObject();
break;
case InstructionType.InitArray:
instruction = new InitArray();
break;
case InstructionType.InitObject:
instruction = new InitObject();
break;
case InstructionType.TypeOf:
instruction = new TypeOf();
break;
case InstructionType.Add2:
instruction = new Add2();
break;
case InstructionType.LessThan2:
instruction = new LessThan2();
break;
case InstructionType.Equals2:
instruction = new Equals2();
break;
case InstructionType.ToString:
instruction = new ToString();
break;
case InstructionType.PushDuplicate:
instruction = new PushDuplicate();
break;
case InstructionType.GetMember:
instruction = new GetMember();
break;
case InstructionType.SetMember:
instruction = new SetMember();
break;
case InstructionType.Increment:
instruction = new Increment();
break;
case InstructionType.Decrement:
instruction = new Decrement();
break;
case InstructionType.CallMethod:
instruction = new CallMethod();
break;
case InstructionType.Enumerate2:
instruction = new Enumerate2();
break;
case InstructionType.EA_PushThis:
instruction = new PushThis();
break;
case InstructionType.EA_PushZero:
instruction = new PushZero();
break;
case InstructionType.EA_PushOne:
instruction = new PushOne();
break;
case InstructionType.EA_CallFunc:
instruction = new CallFunc();
break;
case InstructionType.EA_CallMethodPop:
instruction = new CallMethodPop();
break;
case InstructionType.BitwiseXOr:
instruction = new BitwiseXOr();
break;
case InstructionType.Greater:
instruction = new Greater();
break;
case InstructionType.EA_PushThisVar:
instruction = new PushThisVar();
break;
case InstructionType.EA_PushGlobalVar:
instruction = new PushGlobalVar();
break;
case InstructionType.EA_ZeroVar:
instruction = new ZeroVar();
break;
case InstructionType.EA_PushTrue:
instruction = new PushTrue();
break;
case InstructionType.EA_PushFalse:
instruction = new PushFalse();
break;
case InstructionType.EA_PushNull:
instruction = new PushNull();
break;
case InstructionType.EA_PushUndefined:
instruction = new PushUndefined();
break;
case InstructionType.GotoFrame:
instruction = new GotoFrame();
parameters.Add(Value.FromInteger(_reader.ReadInt32()));
break;
case InstructionType.GetURL:
instruction = new GetUrl();
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
break;
case InstructionType.SetRegister:
instruction = new SetRegister();
parameters.Add(Value.FromInteger(_reader.ReadInt32()));
break;
case InstructionType.ConstantPool:
{
instruction = new ConstantPool();
var count = _reader.ReadUInt32();
var constants = _reader.ReadFixedSizeArrayAtOffset <uint>(() => _reader.ReadUInt32(), count);
foreach (var constant in constants)
{
parameters.Add(Value.FromConstant(constant));
}
}
break;
case InstructionType.GotoLabel:
instruction = new GotoLabel();
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
break;
case InstructionType.DefineFunction2:
{
instruction = new DefineFunction2();
var name = _reader.ReadStringAtOffset();
var nParams = _reader.ReadUInt32();
var nRegisters = _reader.ReadByte();
var flags = _reader.ReadUInt24();
//list of parameter strings
var paramList = _reader.ReadFixedSizeListAtOffset <FunctionArgument>(() => new FunctionArgument()
{
Register = _reader.ReadInt32(),
Parameter = _reader.ReadStringAtOffset(),
}, nParams);
parameters.Add(Value.FromString(name));
parameters.Add(Value.FromInteger((int)nParams));
parameters.Add(Value.FromInteger((int)nRegisters));
parameters.Add(Value.FromInteger((int)flags));
foreach (var param in paramList)
{
parameters.Add(Value.FromInteger(param.Register));
parameters.Add(Value.FromString(param.Parameter));
}
//body size of the function
parameters.Add(Value.FromInteger(_reader.ReadInt32()));
//skip 8 bytes
_reader.ReadUInt64();
}
break;
case InstructionType.PushData:
{
instruction = new PushData();
var count = _reader.ReadUInt32();
var constants = _reader.ReadFixedSizeArrayAtOffset <uint>(() => _reader.ReadUInt32(), count);
foreach (var constant in constants)
{
parameters.Add(Value.FromConstant(constant));
}
}
break;
case InstructionType.BranchAlways:
instruction = new BranchAlways();
if (!branched)
{
branchBytes = _reader.ReadInt32();
parameters.Add(Value.FromInteger(branchBytes));
if (branchBytes > 0)
{
branchBytes += (int)instruction.Size + 1;
branched = true;
}
}
else
{
parameters.Add(Value.FromInteger(_reader.ReadInt32()));
}
break;
case InstructionType.GetURL2:
instruction = new GetUrl2();
break;
case InstructionType.DefineFunction:
{
instruction = new DefineFunction();
var name = _reader.ReadStringAtOffset();
//list of parameter strings
var paramList = _reader.ReadListAtOffset <string>(() => _reader.ReadStringAtOffset());
parameters.Add(Value.FromString(name));
parameters.Add(Value.FromInteger(paramList.Count));
foreach (var param in paramList)
{
parameters.Add(Value.FromString(param));
}
//body size of the function
parameters.Add(Value.FromInteger(_reader.ReadInt32()));
//skip 8 bytes
_reader.ReadUInt64();
}
break;
case InstructionType.BranchIfTrue:
instruction = new BranchIfTrue();
if (!branched)
{
branchBytes = _reader.ReadInt32();
parameters.Add(Value.FromInteger(branchBytes));
if (branchBytes > 0)
{
branchBytes += (int)instruction.Size + 1;
branched = true;
}
}
else
{
parameters.Add(Value.FromInteger(_reader.ReadInt32()));
}
break;
case InstructionType.GotoFrame2:
instruction = new GotoFrame2();
parameters.Add(Value.FromInteger(_reader.ReadByte()));
break;
case InstructionType.EA_PushString:
instruction = new PushString();
//the constant id that should be pushed
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
break;
case InstructionType.EA_PushConstantByte:
instruction = new PushConstantByte();
//the constant id that should be pushed
parameters.Add(Value.FromConstant(_reader.ReadByte()));
break;
case InstructionType.EA_GetStringVar:
instruction = new GetStringVar();
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
break;
case InstructionType.EA_SetStringVar:
instruction = new SetStringVar();
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
break;
case InstructionType.EA_GetStringMember:
instruction = new GetStringMember();
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
break;
case InstructionType.EA_SetStringMember:
instruction = new SetStringMember();
parameters.Add(Value.FromString(_reader.ReadStringAtOffset()));
break;
case InstructionType.EA_PushValueOfVar:
instruction = new PushValueOfVar();
//the constant id that should be pushed
parameters.Add(Value.FromConstant(_reader.ReadByte()));
break;
case InstructionType.EA_GetNamedMember:
instruction = new GetNamedMember();
parameters.Add(Value.FromConstant(_reader.ReadByte()));
break;
case InstructionType.EA_CallNamedFuncPop:
instruction = new CallNamedFuncPop();
parameters.Add(Value.FromConstant(_reader.ReadByte()));
break;
case InstructionType.EA_CallNamedFunc:
instruction = new CallNamedFunc();
parameters.Add(Value.FromConstant(_reader.ReadByte()));
break;
case InstructionType.EA_CallNamedMethodPop:
instruction = new CallNamedMethodPop();
parameters.Add(Value.FromConstant(_reader.ReadByte()));
break;
case InstructionType.EA_PushFloat:
instruction = new PushFloat();
parameters.Add(Value.FromFloat(_reader.ReadSingle()));
break;
case InstructionType.EA_PushByte:
instruction = new PushByte();
parameters.Add(Value.FromInteger(_reader.ReadByte()));
break;
case InstructionType.EA_PushShort:
instruction = new PushShort();
parameters.Add(Value.FromInteger(_reader.ReadUInt16()));
break;
case InstructionType.End:
instruction = new End();
if (!branched)
{
parsing = false;
}
break;
case InstructionType.EA_CallNamedMethod:
instruction = new CallNamedMethod();
parameters.Add(Value.FromConstant(_reader.ReadByte()));
break;
case InstructionType.Var:
instruction = new Var();
break;
case InstructionType.EA_PushRegister:
instruction = new PushRegister();
parameters.Add(Value.FromInteger(_reader.ReadByte()));
break;
case InstructionType.EA_PushConstantWord:
instruction = new PushConstantWord();
parameters.Add(Value.FromConstant(_reader.ReadUInt16()));
break;
case InstructionType.EA_CallFuncPop:
instruction = new CallFunctionPop();
break;
case InstructionType.StrictEqual:
instruction = new StrictEquals();
break;
default:
throw new InvalidDataException("Unimplemented bytecode instruction:" + type.ToString());
}
if (instruction != null)
{
instruction.Parameters = parameters;
Items.Add(instruction);
}
if (branched)
{
branchBytes -= (int)instruction.Size + 1;
if (branchBytes <= 0)
{
branched = false;
}
}
}
_reader.BaseStream.Seek(current, SeekOrigin.Begin);
}
public Term random_int_1(Term val0)
{
Term result = new Var();
if (!(val0 is Number))
{
throw new Exception(
"random_int requires a bound integer parameter.");
}
int n = ((alice.tuprolog.Number)val0).intValue();
java.lang.Double d = new java.lang.Double(1 + (_random.NextDouble() * n));
unify(result, new alice.tuprolog.Int(d.intValue()));
return result;
}
public override bool DeclareVar(string name, string type)
{
Var var = null;
if(declaredVars.TryGetValue(name, out var)) {
if(var.DataType.ToLower() != type.ToLower())
throw new ApplicationException("Variable already declared with different type: " + name);
if(!var.IsDeclared) {
RawDeclareVar(name, type);
var.IsDeclared = true;
}
return true;
}
RawDeclareVar(name, type);
var = new Var();
var.DataType = type;
var.IsSet = true;
var.IsDeclared = true;
declaredVars[name] = var;
return false;
}
internal Expression GenVar(GenContext context, Var var)
{
int i = (int)_vars.valAt(var);
return GenConstant(context, i, var);
}
private GoPromise(Var <Try <T> > result) : base(result)
{
_result = result;
}
public VarExpr(Var var, Symbol tag)
{
_var = var;
_tag = tag ?? var.Tag;
}
private VarDefinitionRemapper(Var oldVar, Command command)
: base(command)
{
m_oldVar = oldVar;
}
internal SortKey(Var v, bool asc, string collation)
{
Var = v;
m_asc = asc;
m_collation = collation;
}
internal static ObjExpr Build(
IPersistentVector interfaceSyms,
IPersistentVector fieldSyms,
Symbol thisSym,
string tagName,
Symbol className,
Symbol typeTag,
ISeq methodForms,
Object frm)
{
NewInstanceExpr ret = new NewInstanceExpr(null);
ret._src = frm;
ret._name = className.ToString();
ret._classMeta = GenInterface.ExtractAttributes(RT.meta(className));
ret.InternalName = ret._name; // ret.Name.Replace('.', '/');
// Java: ret.objtype = Type.getObjectType(ret.internalName);
if (thisSym != null)
{
ret._thisName = thisSym.Name;
}
if (fieldSyms != null)
{
IPersistentMap fmap = PersistentHashMap.EMPTY;
object[] closesvec = new object[2 * fieldSyms.count()];
for (int i = 0; i < fieldSyms.count(); i++)
{
Symbol sym = (Symbol)fieldSyms.nth(i);
LocalBinding lb = new LocalBinding(-1, sym, null, new MethodParamExpr(Compiler.TagType(Compiler.TagOf(sym))), false, false, false);
fmap = fmap.assoc(sym, lb);
closesvec[i * 2] = lb;
closesvec[i * 2 + 1] = lb;
}
// Java TODO: inject __meta et al into closes - when?
// use array map to preserve ctor order
ret.Closes = new PersistentArrayMap(closesvec);
ret.Fields = fmap;
for (int i = fieldSyms.count() - 1; i >= 0 && (((Symbol)fieldSyms.nth(i)).Name.Equals("__meta") || ((Symbol)fieldSyms.nth(i)).Name.Equals("__extmap")); --i)
{
ret._altCtorDrops++;
}
}
// Java TODO: set up volatiles
//ret._volatiles = PersistentHashSet.create(RT.seq(RT.get(ret._optionsMap, volatileKey)));
IPersistentVector interfaces = PersistentVector.EMPTY;
for (ISeq s = RT.seq(interfaceSyms); s != null; s = s.next())
{
Type t = (Type)Compiler.Resolve((Symbol)s.first());
if (!t.IsInterface)
{
throw new ParseException("only interfaces are supported, had: " + t.Name);
}
interfaces = interfaces.cons(t);
}
Type superClass = typeof(Object);
Dictionary <IPersistentVector, List <MethodInfo> > overrideables;
GatherMethods(superClass, RT.seq(interfaces), out overrideables);
ret._methodMap = overrideables;
GenContext context = Compiler.IsCompiling
? Compiler.CompilerContextVar.get() as GenContext
: (ret.IsDefType
? GenContext.CreateWithExternalAssembly("deftype" + RT.nextID().ToString(), ".dll", true)
: (Compiler.CompilerContextVar.get() as GenContext
??
Compiler.EvalContext));
GenContext genC = context.WithNewDynInitHelper(ret.InternalName + "__dynInitHelper_" + RT.nextID().ToString());
Type stub = CompileStub(genC, superClass, ret, SeqToTypeArray(interfaces), frm);
Symbol thisTag = Symbol.intern(null, stub.FullName);
//Symbol stubTag = Symbol.intern(null,stub.FullName);
//Symbol thisTag = Symbol.intern(null, tagName);
try
{
Var.pushThreadBindings(
RT.map(
Compiler.ConstantsVar, PersistentVector.EMPTY,
Compiler.ConstantIdsVar, new IdentityHashMap(),
Compiler.KeywordsVar, PersistentHashMap.EMPTY,
Compiler.VarsVar, PersistentHashMap.EMPTY,
Compiler.KeywordCallsitesVar, PersistentVector.EMPTY,
Compiler.ProtocolCallsitesVar, PersistentVector.EMPTY,
Compiler.VarCallsitesVar, Compiler.EmptyVarCallSites(),
Compiler.NoRecurVar, null,
Compiler.CompilerContextVar, genC
));
if (ret.IsDefType)
{
Var.pushThreadBindings(
RT.map(
Compiler.MethodVar, null,
Compiler.LocalEnvVar, ret.Fields,
Compiler.CompileStubSymVar, Symbol.intern(null, tagName),
Compiler.CompileStubClassVar, stub
));
ret._hintedFields = RT.subvec(fieldSyms, 0, fieldSyms.count() - ret._altCtorDrops);
}
// now (methodname [args] body)*
ret.SpanMap = (IPersistentMap)Compiler.SourceSpanVar.deref();
IPersistentCollection methods = null;
for (ISeq s = methodForms; s != null; s = RT.next(s))
{
NewInstanceMethod m = NewInstanceMethod.Parse(ret, (ISeq)RT.first(s), thisTag, overrideables);
methods = RT.conj(methods, m);
}
ret._methods = methods;
ret.Keywords = (IPersistentMap)Compiler.KeywordsVar.deref();
ret.Vars = (IPersistentMap)Compiler.VarsVar.deref();
ret.Constants = (PersistentVector)Compiler.ConstantsVar.deref();
ret._constantsID = RT.nextID();
ret.KeywordCallsites = (IPersistentVector)Compiler.KeywordCallsitesVar.deref();
ret.ProtocolCallsites = (IPersistentVector)Compiler.ProtocolCallsitesVar.deref();
ret.VarCallsites = (IPersistentSet)Compiler.VarCallsitesVar.deref();
}
finally
{
if (ret.IsDefType)
{
Var.popThreadBindings();
}
Var.popThreadBindings();
}
// TOD: Really, the first stub here should be 'superclass' but can't handle hostexprs nested in method bodies -- reify method compilation takes place before this sucker is compiled, so can't replace the call.
// Might be able to flag stub classes and not try to convert, leading to a dynsite.
//if (RT.CompileDLR)
ret.Compile(stub, stub, interfaces, false, genC);
//else
// ret.CompileNoDlr(stub, stub, interfaces, false, genC);
Compiler.RegisterDuplicateType(ret.CompiledType);
return(ret);
}
internal void EmitVar(CljILGen ilg, Var var)
{
int i = (int)Vars.valAt(var);
EmitConstant(ilg, i, var);
}
public virtual void PostWalk(Var node) { }
public TgTransport(MtProtoCipherTransport transport, Var <Session> session)
{
_transport = transport;
_session = session;
_receiveLoopTask = Task.Run(ReceiveLoop);
}
/// <summary>
/// Return the VarInfo for the specified var (if one exists, of course)
/// </summary>
/// <param name="v"> The Var </param>
/// <param name="varInfo"> the corresponding VarInfo </param>
/// <returns> </returns>
internal bool TryGetVarInfo(Var v, out VarInfo varInfo)
{
return(m_map.TryGetValue(v, out varInfo));
}
public TheVarExpr(Var var)
{
_var = var;
}
public Message ApplyAndDisplay(ArcadeUser user)
{
var builder = new MessageBuilder();
var embedder = new Embedder();
string icon = "💸";
string type = "+";
string quote = Replies.GetReply(Flag, user, this);
long value = Reward;
ImmutableColor color = ImmutableColor.GammaGreen;
Var.Add(user, 1, GimiStats.TimesPlayed);
switch (Flag)
{
case GimiResultFlag.Win:
case GimiResultFlag.Gold:
Var.Clear(user, GimiStats.CurrentCurseStreak, GimiStats.CurrentLossStreak, GimiStats.CurrentLossAmount);
Var.Add(user, 1, GimiStats.TimesWon, GimiStats.CurrentWinStreak);
Var.Add(user, Reward, GimiStats.TotalWon, GimiStats.CurrentWinAmount);
Var.SetIfGreater(user, GimiStats.LongestWin, GimiStats.CurrentWinStreak);
Var.SetIfGreater(user, GimiStats.LargestWin, GimiStats.CurrentWinAmount);
if (Flag == GimiResultFlag.Gold)
{
icon = "💎";
type = "+";
color = GammaPalette.Glass[Gamma.Max];
ItemHelper.GiveItem(user, Items.PocketLawyer);
if (RandomProvider.Instance.Next(0, 1001) == 1000)
{
ItemHelper.GiveItem(user, Items.PaletteGold);
}
Var.Add(user, 1, GimiStats.TimesGold, GimiStats.CurrentGoldStreak);
Var.SetIfGreater(user, GimiStats.LongestGold, GimiStats.CurrentGoldStreak);
}
else
{
Var.Clear(user, GimiStats.CurrentGoldStreak);
Reward = CurrencyHelper.BoostValue(user, Reward, BoostType.Money);
}
long debt = user.Debt;
user.Give(Reward);
if (debt > Reward)
{
icon = "📃";
type = "-";
quote = Replies.Recover.Length > 0 ? (string)Randomizer.Choose(Replies.Recover) : Replies.RecoverGeneric;
}
else if (debt > 0 && Reward - debt == 0)
{
icon = "📧";
type = "";
quote = Replies.EvenGeneric;
}
break;
case GimiResultFlag.Lose:
case GimiResultFlag.Curse:
type = "-";
color = ImmutableColor.NeonRed;
Var.Clear(user, GimiStats.CurrentGoldStreak, GimiStats.CurrentWinStreak, GimiStats.CurrentWinAmount);
Var.Add(user, 1, GimiStats.TimesLost, GimiStats.CurrentLossStreak);
Var.Add(user, Reward, GimiStats.TotalLost, GimiStats.CurrentLossAmount);
Var.SetIfGreater(user, GimiStats.LongestLoss, GimiStats.CurrentLossStreak);
Var.SetIfGreater(user, GimiStats.LargestLoss, GimiStats.CurrentLossAmount);
if (Flag == GimiResultFlag.Curse)
{
icon = "🌕";
type = "-";
color = GammaPalette.Alconia[Gamma.Standard];
Var.Add(user, 1, GimiStats.TimesCursed, GimiStats.CurrentCurseStreak);
Var.SetIfGreater(user, GimiStats.LongestCurse, GimiStats.CurrentCurseStreak);
}
else
{
Var.Clear(user, GimiStats.CurrentCurseStreak);
Reward = CurrencyHelper.BoostValue(user, Reward, BoostType.Money);
}
long balance = user.Balance;
user.Take(Reward);
if (balance < Reward)
{
icon = "📃";
type = "+";
value = Reward - balance;
quote = Replies.Debt.Length > 0 ? (string)Randomizer.Choose(Replies.Debt) : Replies.DebtGeneric;
}
else if (balance > 0 && Reward - balance == 0)
{
icon = "📧";
value = Reward - balance;
type = "";
quote = Replies.EvenGeneric;
}
break;
}
if (!string.IsNullOrWhiteSpace(type))
{
type += ' ';
}
string header = $"**{type}{icon} {value:##,0}**";
string content = $"*\"{quote}\"*";
embedder.Header = header;
embedder.Color = color;
builder.Embedder = embedder;
builder.Content = content;
return(builder.Build());
}
