public override DObject Instantiate(DObject[] inputs, bool initialize = true)
{
var continueAt = i.GetLocation();
// functions should not go to the scope they are defined in, but continue in the scope
// that they were called in, hence i.Goto(definition) is commented out
//i.Goto(definition);
i.pointer = definition.pointer;
DTable instance = (DTable)i.evaluator.tableOp.unaryFunction.Invoke(null);
if (super != null)
{
var @base = super.Instantiate(null, false);
instance.AddMember("base", new ReadOnlyMember(@base));
//@base.AddMember("derived", new ReadOnlyMember(@instance));
}
i.Goto(continueAt);
if (initialize && instance.HasMember("constructor"))
{
instance.CallFunction("constructor", inputs);
}
return(instance);
}
public void LoadPlot()
{
var pairs = from row in DTable.AsEnumerable()
select new KeyValuePair <string, double>((string)row[1], double.Parse(row[3].ToString()));
BarPlot.ItemsSource = pairs.ToArray();
BarPlot.LegendItems.Clear();
BarPlot.LegendItems.Add("% of People");
}
public async Task <string> GetTable()
{
DTable table = new DTable();
table.Initialize(10, 20);
string returnVal = JsonConvert.SerializeObject(table);
return(await Task.Run(() => { return returnVal; }));
}
public void Test_EndRound()
{
DTable table = new DTable();
DUser user1 = new DUser();
DUser user2 = new DUser();
DUser user3 = new DUser();
DCard flop1 = new DCard(0, 5, "Club");
DCard flop2 = new DCard(0, 8, "Club");
DCard flop3 = new DCard(0, 6, "Club");
DCard flop4 = new DCard(0, 14, "Diamond");
DCard flop5 = new DCard(0, 14, "Spade");
DCard user11 = new DCard(0, 14, "Club");
DCard user12 = new DCard(0, 14, "Heart");
DCard user21 = new DCard(0, 3, "Club");
DCard user22 = new DCard(0, 4, "Club");
DCard user31 = new DCard(0, 13, "Club");
DCard user32 = new DCard(0, 12, "Club");
table.Initialize(5, 10);
user1.ChipTotal = 100;
user2.ChipTotal = 100;
user3.ChipTotal = 100;
table.JoinGame(user1);
table.JoinGame(user2);
table.JoinGame(user3);
table.StartGame();
table.GetTurnOrder();
table.SeatsInTurnOrder[0].RoundBid = 15;
table.SeatsInTurnOrder[1].RoundBid = 20;
table.SeatsInTurnOrder[2].RoundBid = 20;
foreach (DSeat seat in table.SeatsInTurnOrder)
{
seat.Flop.Add(flop1);
seat.Flop.Add(flop2);
seat.Flop.Add(flop3);
seat.Flop.Add(flop4);
seat.Flop.Add(flop5);
}
table.SeatsInTurnOrder[0].Pocket.Add(user11);
table.SeatsInTurnOrder[0].Pocket.Add(user12);
table.SeatsInTurnOrder[1].Pocket.Add(user21);
table.SeatsInTurnOrder[1].Pocket.Add(user22);
table.SeatsInTurnOrder[2].Pocket.Add(user31);
table.SeatsInTurnOrder[2].Pocket.Add(user32);
table.EndRound();
Assert.Equal(145, table.SeatsInTurnOrder[0].ChipTotal);
Assert.Equal(100, table.SeatsInTurnOrder[1].ChipTotal);
Assert.Equal(110, table.SeatsInTurnOrder[2].ChipTotal);
Assert.True(table.SeatsInTurnOrder[2].BigBlind);
}
public async Task <IActionResult> EndRound(string jsonTable)
{
DTable table = JsonConvert.DeserializeObject <DTable>(jsonTable);
table.EndRound();
string returnVal = JsonConvert.SerializeObject(table);
return(await Task.Run(() => { return Ok(returnVal); }));
}
public async Task <string> JoinTable(string jsonTable, string jsonUser)
{
DTable table = JsonConvert.DeserializeObject <DTable>(jsonTable);
DUser player = JsonConvert.DeserializeObject <DUser>(jsonUser);
table.JoinGame(player);
string returnVal = JsonConvert.SerializeObject(table);
return(await Task.Run(() => { return returnVal; }));
}
public void Test_JoinGame()
{
DTable table = new DTable();
DUser user1 = new DUser();
DUser user2 = new DUser();
table.Initialize(5, 10);
user1.ChipTotal = 100;
user2.ChipTotal = 100;
Assert.True(table.JoinGame(user1));
Assert.True(table.JoinGame(user2));
Assert.Equal(100, user1.ChipTotal);
}
public void Test_NumOfActivePlayers()
{
DTable table = new DTable();
DUser user1 = new DUser();
DUser user2 = new DUser();
table.Initialize(5, 10);
user1.ChipTotal = 100;
user2.ChipTotal = 100;
table.JoinGame(user1);
table.JoinGame(user2);
Assert.Equal(2, table.NumOfActivePlayers());
}
public async Task <IActionResult> StartRound(string jsonTable)
{
DTable table = JsonConvert.DeserializeObject <DTable>(jsonTable);
table.StartRound();
for (int i = 0; i < 5; i++)
{
table.Flop.Add(table.DeckOfCards.Draw());
}
string returnVal = JsonConvert.SerializeObject(table);
return(await Task.Run(() => { return Ok(returnVal); }));
}
public void Test_StartGame()
{
DTable table = new DTable();
DUser user1 = new DUser();
DUser user2 = new DUser();
table.Initialize(5, 10);
user1.ChipTotal = 100;
user2.ChipTotal = 100;
table.JoinGame(user1);
table.JoinGame(user2);
table.StartGame();
Assert.True(table.Seats[0].SmallBlind);
Assert.True(table.Seats[1].BigBlind);
}
public void Test_StartRound()
{
DTable table = new DTable();
DUser user1 = new DUser();
DUser user2 = new DUser();
table.Initialize(5, 10);
user1.ChipTotal = 100;
user2.ChipTotal = 100;
table.JoinGame(user1);
table.JoinGame(user2);
table.StartGame();
table.StartRound();
Assert.Equal(95, table.SeatsInTurnOrder[0].ChipTotal);
Assert.Equal(90, table.SeatsInTurnOrder[1].ChipTotal);
Assert.Equal(2, table.SeatsInTurnOrder[0].Pocket.Count);
}
public void Test_MoveBlinds()
{
DTable table = new DTable();
DUser user1 = new DUser();
DUser user2 = new DUser();
DUser user3 = new DUser();
table.Initialize(5, 10);
user1.ChipTotal = 100;
user2.ChipTotal = 100;
user3.ChipTotal = 100;
table.JoinGame(user1);
table.JoinGame(user2);
table.JoinGame(user3);
table.StartGame();
table.GetTurnOrder();
table.MoveBlinds();
Assert.True(table.SeatsInTurnOrder[2].BigBlind);
Assert.True(table.SeatsInTurnOrder[1].SmallBlind);
}
public Evaluator(Interpreter interpreter)
{
i = interpreter;
interpreter.evaluator = this;
var throwStatement = new Operation("throw")
{
association = Operation.Association.Right,
unaryFunction = (right) =>
{
throw i.Exception(right.ToString());
}
};
var tryCatch = new Operation("try")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
int depth = i.GetLocation().depth;
try
{
i.ExecuteBlock();
i.Eat("catch");
i.EatUntilToken("l curly");
i.SkipBlock();
}
catch (InterpreterException e)
{
i.SkipToDepth(depth);
i.Eat("catch");
string exceptionName = null;
string lineName = null;
string columnName = null;
if (i.CurrentToken == "of")
{
i.Eat();
exceptionName = i.GetIdentifier();
i.heap.DeclareReadOnly(exceptionName, new DException(e.message.ToDString()));
if (i.CurrentToken == "comma")
{
i.Eat();
lineName = i.GetIdentifier();
i.heap.DeclareReadOnly(lineName, e.location.line.ToDNumber());
}
if (i.CurrentToken == "comma")
{
i.Eat();
columnName = i.GetIdentifier();
i.heap.DeclareReadOnly(columnName, e.location.column.ToDNumber());
}
}
i.ExecuteBlock();
if (exceptionName != null)
{
i.heap.DeleteLocal(exceptionName);
}
if (lineName != null)
{
i.heap.DeleteLocal(lineName);
}
if (columnName != null)
{
i.heap.DeleteLocal(columnName);
}
}
return(dvoid);
}
};
var include = new Operation("include")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
var filename = Evaluate <DString>().ToString();
if (i.includes.Contains(filename))
{
throw new InterpreterException(i.CurrentToken, "File has already been included: " + filename);
}
i.TryEat("semicolon");
var tokens = Lexer.ScanFile(filename);
tokens.RemoveAll(x => x == "eof");
i.tokens.InsertRange(i.pointer, tokens);
i.includes.Add(filename);
return(dvoid);
}
};
var charLiteral = new Operation("char")
{
eatOperator = false,
association = Operation.Association.None,
unaryFunction = (none) =>
{
return(i.Eat <char>().ToDChar());
}
};
var baseLiteral = new Operation("base")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
var super = i.functionOwners.Peek().GetMember("base");
lastVariable = super;
if (i.CurrentToken == "l bracket")
{
i.Eat();
var p = i.GetParameters();
((DFunction)super.Value.GetMemberValue("constructor")).Call(p);
}
return(lastVariable.Value);
}
};
var thisLiteral = new Operation("this")
{
association = Operation.Association.None,
unaryFunction = (none) => {
lastVariable = new ReadOnlyVariable(i.functionOwners.Peek(), i.depth);
return(lastVariable.Value);
}
};
var structureLiteral = new Operation("structure")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
DTemplate super = null;
if (i.CurrentToken == "extending")
{
i.Eat();
var extending = Evaluate();
if (extending is DTemplate)
{
super = (DTemplate)extending;
}
else
{
throw new InterpreterException(i.CurrentToken, "Expected a strong template or a weak template");
}
}
var structure = new DWeakTemplate()
{
i = i,
definition = i.GetLocation(),
super = super
};
while (i.CurrentToken != "l curly")
{
i.Eat();
}
i.SkipBlock();
return(structure);
}
};
var funcLiteral = new Operation("function")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.TryEat("of");
var location = i.GetLocation();
DWeakFunction func = new DWeakFunction()
{
i = i,
location = location
};
while (i.CurrentToken != "l curly")
{
i.Eat();
}
i.SkipBlock();
return(func);
}
};
var tableLiteral = new Operation("table")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.UnsafeEat("l curly");
var table = new DTable();
var members = new Dictionary <string, Member>();
var properties = new Dictionary <string, WeakProperty>();
while (i.CurrentToken != "r curly")
{
if (i.CurrentToken == "get")
{
i.Eat();
string name = i.GetIdentifier();
DWeakFunction getter = (DWeakFunction)funcLiteral.unaryFunction.Invoke(null);
getter.owner = table;
properties.Add(name, new WeakProperty(getter));
}
else if (i.CurrentToken == "set")
{
i.Eat();
string name = i.GetIdentifier();
if (!properties.ContainsKey(name))
{
throw i.Exception("Must declare a getter for " + name + " before declaring a setter.");
}
DWeakFunction setter = (DWeakFunction)funcLiteral.unaryFunction.Invoke(null);
setter.owner = table;
properties[name].setter = setter;
}
else if (i.CurrentToken == "with")
{
i.Eat();
string name = i.GetIdentifier();
DObject value = new DUndefined();
if (i.CurrentToken == "equals")
{
i.Eat();
value = Evaluate();
if (value.GetType() == typeof(DWeakFunction))
{
((DWeakFunction)value).owner = table;
}
}
members.Add(name, new Member(value));
}
else if (i.CurrentToken == "constructor")
{
i.Eat();
DWeakFunction ctor = (DWeakFunction)funcLiteral.unaryFunction.Invoke(null);
ctor.owner = table;
members.Add("constructor", new ReadOnlyMember(ctor));
}
else if (i.CurrentToken == "function")
{
i.Eat();
string name = i.GetIdentifier();
DWeakFunction ctor = (DWeakFunction)funcLiteral.unaryFunction.Invoke(null);
ctor.owner = table;
members.Add(name, new Member(ctor));
}
else
{
throw i.Exception("Unexpected token: " + i.CurrentToken.Type);
}
i.TryEat("semicolon");
}
properties.ToList().ForEach(x => members.Add(x.Key, x.Value));
table.SetMembers(members);
i.UnsafeEat("r curly");
return(table);
}
};
tableOp = tableLiteral;
var returnStatement = new Operation("return")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.returnValue = Evaluate();
return(dvoid);
}
};
var continueStatement = new Operation("continue")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.shouldContinue = true;
return(dvoid);
}
};
var breakStatement = new Operation("break")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.shouldBreak = true;
return(dvoid);
}
};
var forEachLoop = new Operation("for")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.Eat("each");
string varName = i.GetIdentifier();
i.Eat("in");
DSet set = Evaluate <DSet>();
var j = i.heap.DeclareLocal(varName);
var beginning = i.GetLocation();
i.BeginLoop(beginning);
foreach (var item in set.items)
{
if (i.shouldBreak)
{
break;
}
j.Value = item.Value;
i.shouldContinue = false;
i.ExecuteLoop();
i.Goto(beginning);
}
i.heap.DeleteLocal(varName);
i.EndLoop();
return(dvoid);
}
};
var forLoop = new Operation("from")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
int from = Evaluate <DNumber>().ToInt();
i.Eat("to");
int to = Evaluate <DNumber>().ToInt();
int increment;
if (from > to)
{
increment = -1;
}
else
{
increment = 1;
}
if (i.CurrentToken == "by")
{
i.Eat();
increment = Evaluate <DNumber>().ToInt();
}
i.Eat("with");
string varName = i.GetIdentifier();
var j = i.heap.DeclareLocal(varName);
var beginning = i.GetLocation();
i.BeginLoop(beginning);
for (int k = from; increment > 0 ? k <to : k> to; k += increment)
{
if (i.shouldBreak)
{
break;
}
j.Value = k.ToDNumber();
i.ExecuteLoop();
i.Goto(beginning);
}
i.heap.DeleteLocal(varName);
i.EndLoop();
return(dvoid);
}
};
var untilLoop = new Operation("until")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
var beginning = i.GetLocation();
i.BeginLoop(beginning);
while (!i.GetCondition())
{
if (i.shouldBreak)
{
break;
}
i.ExecuteLoop();
i.Goto(beginning);
}
i.EndLoop();
return(dvoid);
}
};
/*
* var instantiation = new Operation("new")
* {
* association = Operation.Association.None,
* unaryFunction = (none) =>
* {
* var template = Evaluate<DTemplate>();
* i.Eat("l bracket");
* var args = i.GetParameters();
* return template.Instantiate(args);
* }
* };
*/
var instantiation = new Operation("new")
{
association = Operation.Association.Right,
unaryFunction = (right) =>
{
//var template = Evaluate<DTemplate>();
i.Eat("l bracket");
var args = i.GetParameters();
return(DObject.AssertType <DTemplate>(right).Instantiate(args));
}
};
var whileLoop = new Operation("while")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
var beginning = i.GetLocation();
i.BeginLoop(beginning);
while (i.GetCondition())
{
if (i.shouldBreak)
{
break;
}
i.ExecuteLoop();
i.Goto(beginning);
}
i.EndLoop();
return(dvoid);
}
};
var ifStatement = new Operation("if")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
bool satisfied = i.GetCondition();
if (satisfied)
{
i.ExecuteBlock();
}
else
{
i.SkipBlock();
}
while (i.CurrentToken == "else" && i.NextToken == "if")
{
i.Eat();
i.Eat();
bool meetsCondition = i.GetCondition();
if (satisfied || !meetsCondition)
{
i.SkipBlock();
}
else
{
satisfied = true;
i.ExecuteBlock();
}
}
if (i.CurrentToken == "else")
{
i.Eat();
if (satisfied)
{
i.SkipBlock();
}
else
{
i.ExecuteBlock();
}
}
return(dvoid);
}
};
var openBracket = new Operation("l curly")
{
eatOperator = false,
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.Eat();
return(dvoid);
}
};
var closeBracket = new Operation("r curly")
{
eatOperator = false,
association = Operation.Association.None,
unaryFunction = (none) =>
{
i.Eat();
return(dvoid);
}
};
var preInc = new Operation("increment")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
var right = Evaluate();
return(lastVariable.Value = (DObject.AssertType <DNumber>(lastVariable.Value).ToFloat() + 1).ToDNumber());
}
};
var incAdd = new Operation("add")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
return(lastVariable.Value = lastVariable.Value.OpADD(Evaluate()));
}
};
var incSub = new Operation("subtract")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
return(lastVariable.Value = lastVariable.Value.OpSUB(Evaluate()));
}
};
var postInc = new Operation("increment")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
return(lastVariable.Value = (DObject.AssertType <DNumber>(lastVariable.Value).ToFloat() + 1).ToDNumber());
}
};
var preDec = new Operation("decrement")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
var right = Evaluate();
return(lastVariable.Value = (DObject.AssertType <DNumber>(lastVariable.Value).ToFloat() - 1).ToDNumber());
}
};
var postDec = new Operation("decrement")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
return(lastVariable.Value = (DObject.AssertType <DNumber>(lastVariable.Value).ToFloat() - 1).ToDNumber());
}
};
var semicolon = new Operation("semicolon")
{
association = Operation.Association.None,
unaryFunction = (none) => dvoid
};
var declaration = new Operation("var")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
if (i.CurrentToken == "structure")
{
i.Eat();
string name = i.GetIdentifier();
DWeakTemplate value = (DWeakTemplate)structureLiteral.unaryFunction(null);
i.heap.DeclareLocal(name, value);
}
else if (i.CurrentToken == "table")
{
i.Eat();
string name = i.GetIdentifier();
DTable value = (DTable)tableLiteral.unaryFunction(null);
i.heap.DeclareLocal(name, value);
}
else if (i.CurrentToken == "function")
{
i.Eat();
string name = i.GetIdentifier();
DWeakFunction value = (DWeakFunction)funcLiteral.unaryFunction(null);
i.heap.DeclareLocal(name, value);
}
else
{
string name = i.Eat <string>("identifier");
DObject value = DUndefined.instance;
if (i.CurrentToken == "equals")
{
i.Eat();
value = Evaluate();
}
i.heap.DeclareLocal(name, value);
}
return(dvoid);
}
};
var assignment = new Operation("equals")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
var v = lastVariable;
return(v.Value = Evaluate());
}
};
var identifier = new Operation("identifier")
{
eatOperator = false,
association = Operation.Association.None,
unaryFunction = (none) =>
{
string name = i.Eat <string>("identifier");
if (!i.heap.Exists(name))
{
throw new InterpreterException(i.PreviousToken, "Variable does not exist in this scope: " + name);
}
lastVariable = i.heap.Get(name);
if (i.CurrentToken == "equals")
{
return(DUndefined.instance);
}
return(lastVariable.Value);
}
};
var conditional = new Operation("question mark")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
var ifTrue = Evaluate();
i.Eat("else");
var ifFalse = Evaluate();
if (DObject.AssertType <DBool>(left).ToBool())
{
return(ifTrue);
}
else
{
return(ifFalse);
}
}
};
var traverse = new Operation("dot")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
var name = i.GetIdentifier();
var type = left.GetType();
if (left.HasMember(name))
{
lastVariable = left.GetMember(name);
if (i.CurrentToken == "equals")
{
return(DUndefined.instance);
}
return(lastVariable.Value);
}
else if (StrongTypeRegistry.strongFunctions.ContainsKey(type))
{
var methods = StrongTypeRegistry.strongFunctions[type];
if (methods.ContainsKey(name))
{
var method = methods[name];
lastVariable = null;
return(new DStrongFunction(method, left));
}
else if (left.HasMember("base"))
{
i.pointer -= 2; // recurse back to the dot, with base being the new left side
return(left.GetMemberValue("base"));
}
}
else if (left.HasMember("base"))
{
i.pointer -= 2; // recurse back to the dot, with base being the new left side
return(left.GetMemberValue("base"));
}
throw new InterpreterException(i.CurrentToken, "Object (" + type.Name + ") does not contain member: " + name);
}
};
var methodCall = new Operation("l bracket")
{
association = Operation.Association.Left,
unaryFunction = (left) => {
var parameters = i.GetParameters();
if (left is DFunction)
{
return(((DFunction)left).Call(parameters));
}
else if (left is DTemplate)
{
return(((DTemplate)left).Instantiate(parameters));
}
else
{
throw i.Exception("Can only invoke a function or a template, not a " + left.GetType().Name);
}
}
};
/*var eof = new Operation("eof")
* {
* eatOperator = false,
* association = Operation.Association.None,
* unaryFunction = (none) => DUndefined.instance
* };*/
var arrayLiteral = new Operation("l square")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
List <DObject> p = new List <DObject>();
if (i.CurrentToken == "r square")
{
i.Eat();
return(new DSet(new List <DObject>()));
}
bool firstTime = true;
do
{
if (!firstTime)
{
i.Eat("comma");
}
p.Add(Evaluate());
firstTime = false;
}while (i.CurrentToken == "comma");
i.Eat("r square");
return(new DSet(p));
}
};
var undefinedLiteral = new Operation("undefined")
{
association = Operation.Association.None,
unaryFunction = (none) => DUndefined.instance
};
var numberLiteral = new Operation("number")
{
eatOperator = false,
association = Operation.Association.None,
unaryFunction = (none) => i.Eat <float>().ToDNumber()
};
var stringLiteral = new Operation("string")
{
eatOperator = false,
association = Operation.Association.None,
unaryFunction = (none) => i.Eat <string>().ToDString()
};
var boolLiteral = new Operation("bool")
{
eatOperator = false,
association = Operation.Association.None,
unaryFunction = (none) => i.Eat <bool>().ToDBool()
};
var index = new Operation("l square")
{
association = Operation.Association.Left,
unaryFunction = (left) =>
{
lastVariable = left.OpINDEX(Evaluate());
i.Eat("r square");
return(lastVariable.Value);
}
};
var bracket = new Operation("l bracket")
{
association = Operation.Association.None,
unaryFunction = (none) =>
{
var result = Evaluate();
i.Eat("r bracket");
return(result);
}
};
var neg = new Operation("minus")
{
association = Operation.Association.Right,
unaryFunction = (right) => right.OpNEG()
};
var pow = new Operation("exponent")
{
binaryFunction = (left, right) => left.OpPOW(right)
};
var mul = new Operation("multiply")
{
binaryFunction = (left, right) => left.OpMUL(right)
};
var div = new Operation("divide")
{
binaryFunction = (left, right) => left.OpDIV(right)
};
var mod = new Operation("modulus")
{
binaryFunction = (left, right) => left.OpMOD(right)
};
var add = new Operation("plus")
{
binaryFunction = (left, right) => left.OpADD(right)
};
var sub = new Operation("minus")
{
binaryFunction = (left, right) => left.OpSUB(right)
};
var not = new Operation("not")
{
association = Operation.Association.Right,
unaryFunction = (right) => DObject.AssertType <DBool>(right).OpNOT()
};
var eq = new Operation("double equal")
{
binaryFunction = (left, right) => left.OpEQ(right)
};
var neq = new Operation("not equal")
{
binaryFunction = (left, right) => left.OpNEQ(right)
};
var gr = new Operation("greater than")
{
binaryFunction = (left, right) => left.OpGR(right)
};
var ls = new Operation("less than")
{
binaryFunction = (left, right) => left.OpLS(right)
};
var geq = new Operation("greater or equal")
{
binaryFunction = (left, right) => left.OpGEQ(right)
};
var leq = new Operation("less or equal")
{
binaryFunction = (left, right) => left.OpLEQ(right)
};
var and = new Operation("and")
{
binaryFunction = (left, right) => DObject.AssertType <DBool>(left).OpAND(DObject.AssertType <DBool>(right))
};
var or = new Operation("or")
{
binaryFunction = (left, right) => {
if (left is DUndefined)
{
return(right);
}
else if (left.GetType() == typeof(DBool) && right.GetType() == typeof(DBool))
{
return(((DBool)left).OpOR((DBool)right));
}
return(left);
//return DObject.AssertType<DBool>(left).OpOR(DObject.AssertType<DBool>(right));
}
};
//operations.Add(eof);
void register(Operation op)
{
precedences.Last().Add(op);
}
void precedence()
{
precedences.Add(new List <Operation>());
}
precedence();
register(thisLiteral);
register(baseLiteral);
register(bracket);
register(undefinedLiteral);
register(arrayLiteral);
register(numberLiteral);
register(stringLiteral);
register(boolLiteral);
register(tableLiteral);
register(charLiteral);
//register(instantiation);
precedence();
register(identifier);
register(methodCall);
register(traverse);
register(index);
precedence();
register(assignment);
register(preInc);
register(postInc);
register(preDec);
register(postDec);
register(incAdd);
register(incSub);
precedence();
register(neg);
register(not);
precedence();
register(pow);
precedence();
register(mul);
register(div);
register(mod);
precedence();
register(add);
register(sub);
precedence();
register(eq);
register(neq);
register(gr);
register(ls);
register(geq);
register(leq);
precedence();
register(and);
precedence();
register(or);
precedence();
register(conditional);
precedence();
register(semicolon);
register(declaration);
register(closeBracket);
register(openBracket);
register(ifStatement);
register(whileLoop);
register(untilLoop);
register(forEachLoop);
register(continueStatement);
register(breakStatement);
register(funcLiteral);
register(returnStatement);
register(forLoop);
register(structureLiteral);
register(include);
register(tryCatch);
register(throwStatement);
}
private static void Main()
//****************************************************************************80
//
// Purpose:
//
// MAIN is the main program for FD1D_HEAT_IMPLICIT.
//
// Discussion:
//
// FD1D_HEAT_IMPLICIT solves the 1D heat equation with an implicit method.
//
// This program solves
//
// dUdT - k * d2UdX2 = F(X,T)
//
// over the interval [A,B] with boundary conditions
//
// U(A,T) = UA(T),
// U(B,T) = UB(T),
//
// over the time interval [T0,T1] with initial conditions
//
// U(X,T0) = U0(X)
//
// The code uses the finite difference method to approximate the
// second derivative in space, and an implicit backward Euler approximation
// to the first derivative in time.
//
// The finite difference form can be written as
//
// U(X,T+dt) - U(X,T) ( U(X-dx,T) - 2 U(X,T) + U(X+dx,T) )
// ------------------ = F(X,T) + k * ------------------------------------
// dt dx * dx
//
// so that we have the following linear system for the values of U at time T+dt:
//
// - k * dt / dx / dx * U(X-dt,T+dt)
// + ( 1 + 2 * k * dt / dx / dx ) * U(X, T+dt)
// - k * dt / dx / dx * U(X+dt,T+dt)
// = dt * F(X, T+dt)
// + U(X, T)
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 31 May 2009
//
// Author:
//
// John Burkardt
//
{
int i;
int j;
Console.WriteLine("");
Console.WriteLine("FD1D_HEAT_IMPLICIT");
Console.WriteLine("");
Console.WriteLine(" Finite difference solution of");
Console.WriteLine(" the time dependent 1D heat equation");
Console.WriteLine("");
Console.WriteLine(" Ut - k * Uxx = F(x,t)");
Console.WriteLine("");
Console.WriteLine(" for space interval A <= X <= B with boundary conditions");
Console.WriteLine("");
Console.WriteLine(" U(A,t) = UA(t)");
Console.WriteLine(" U(B,t) = UB(t)");
Console.WriteLine("");
Console.WriteLine(" and time interval T0 <= T <= T1 with initial condition");
Console.WriteLine("");
Console.WriteLine(" U(X,T0) = U0(X).");
Console.WriteLine("");
Console.WriteLine(" A second order difference approximation is used for Uxx.");
Console.WriteLine("");
Console.WriteLine(" A first order backward Euler difference approximation");
Console.WriteLine(" is used for Ut.");
const double k = 5.0E-07;
//
// Set X values.
//
const double x_min = 0.0;
const double x_max = 0.3;
const int x_num = 11;
const double x_delt = (x_max - x_min) / (x_num - 1);
double[] x = new double[x_num];
for (i = 0; i < x_num; i++)
{
x[i] = ((x_num - i - 1) * x_min
+ i * x_max)
/ (x_num - 1);
}
//
// Set T values.
//
const double t_min = 0.0;
const double t_max = 22000.0;
const int t_num = 51;
const double t_delt = (t_max - t_min) / (t_num - 1);
double[] t = new double[t_num];
for (j = 0; j < t_num; j++)
{
t[j] = ((t_num - j - 1) * t_min
+ j * t_max)
/ (t_num - 1);
}
//
// Set the initial data, for time T_MIN.
//
double[] u = new double[x_num * t_num];
u0(x_min, x_max, t_min, x_num, x, ref u);
//
// The matrix A does not change with time. We can set it once,
// factor it once, and solve repeatedly.
//
double w = k * t_delt / x_delt / x_delt;
double[] a = new double[3 * x_num];
a[0 + 0 * 3] = 0.0;
a[1 + 0 * 3] = 1.0;
a[0 + 1 * 3] = 0.0;
for (i = 1; i < x_num - 1; i++)
{
a[2 + (i - 1) * 3] = -w;
a[1 + i * 3] = 1.0 + 2.0 * w;
a[0 + (i + 1) * 3] = -w;
}
a[2 + (x_num - 2) * 3] = 0.0;
a[1 + (x_num - 1) * 3] = 1.0;
a[2 + (x_num - 1) * 3] = 0.0;
//
// Factor the matrix.
//
typeMethods.r83_np_fa(x_num, ref a);
double[] b = new double[x_num];
double[] fvec = new double[x_num];
for (j = 1; j < t_num; j++)
{
//
// Set the right hand side B.
//
b[0] = ua(x_min, x_max, t_min, t[j]);
f(x_min, x_max, t_min, t[j - 1], x_num, x, ref fvec);
for (i = 1; i < x_num - 1; i++)
{
b[i] = u[i + (j - 1) * x_num] + t_delt * fvec[i];
}
b[x_num - 1] = ub(x_min, x_max, t_min, t[j]);
int job = 0;
fvec = typeMethods.r83_np_sl(x_num, a, b, job);
for (i = 0; i < x_num; i++)
{
u[i + j * x_num] = fvec[i];
}
}
const string x_file = "x.txt";
DTable.dtable_write(x_file, 1, x_num, x, false);
Console.WriteLine("");
Console.WriteLine(" X data written to \"" + x_file + "\".");
const string t_file = "t.txt";
DTable.dtable_write(t_file, 1, t_num, t, false);
Console.WriteLine(" T data written to \"" + t_file + "\".");
const string u_file = "u.txt";
DTable.dtable_write(u_file, x_num, t_num, u, false);
Console.WriteLine(" U data written to \"" + u_file + "\".");
Console.WriteLine("");
Console.WriteLine("FD1D_HEAT_IMPLICIT");
Console.WriteLine(" Normal end of execution.");
Console.WriteLine("");
}
