private async Task <List <EngineResult> > GetResults(string text)
{
_logger.LogDebug($"Processing {text}");
var results = new ConcurrentBag <EngineResult>();
var promises = _engines.Select(async engine =>
{
var engineResult = new EngineResult()
{
EngineName = engine.Name,
Text = text,
Count = await engine.GetResultsCount(text)
};
results.Add(engineResult);
}
);
try
{
await Task.WhenAll(promises);
}
catch (AggregateException)
{
_logger.LogError("Not all engines success.");
throw;
}
return(results.OrderBy(r => r.Count).ToList());
}
public void EnsureMaximizingPlayerWinsAfterOpponentBadMove()
{
var game = TicTacToeGame.Classic;
game.DoMove(new TicTacToeMove()
{
X = 1,
Y = 1,
});
// bad for Minimizing player move
game.DoMove(new TicTacToeMove()
{
X = 0,
Y = 1,
});
int step = 1;
// play as AI wants till the end
while (!game.State.IsTerminate)
{
EngineResult aiResult = _ai.Analyse(game);
game.DoMove(aiResult.BestMove);
// Maximizing wins estimation all the way till the end
Assert.IsTrue(aiResult.Estimate.IsCloseTo(Estimate.MaxInf), $"step {step} -- win MAX estimation expected");
step += 1;
}
Assert.IsTrue(game.State.IsTerminate);
Assert.IsTrue(game.State.StaticEstimate.IsCloseTo(Estimate.MaxInf));
}
public void CheckFirstMove()
{
var game = TicTacToeGame.Classic;
EngineResult aiResult = _ai.Analyse(game);
TicTacToeMove bestMove = aiResult.BestMove as TicTacToeMove;
Assert.IsNotNull(aiResult);
Assert.IsNotNull(bestMove);
// check it's one of good first moves -- 4 corners or center
var goodMoves = new[]
{
Tuple.Create(0, 0),
Tuple.Create(2, 0),
Tuple.Create(0, 2),
Tuple.Create(2, 2),
Tuple.Create(0, 0),
};
bool goodMove = false;
foreach (var p in goodMoves)
{
if (bestMove.X == p.Item1 && bestMove.Y == p.Item2)
{
goodMove = true;
break;
}
}
Assert.IsTrue(goodMove, $"first move is bad: {bestMove}");
}
public void TestCase2()
{
// -------
// |o|x|x|
// -------
// |x|o|*|
// -------
// |o| |x|
// -------
// * -- expected next move
var game = TicTacToeGame.Classic;
game.State.SetCell(0, 0, Player.Minimizing);
game.State.SetCell(1, 0, Player.Maximizing);
game.State.SetCell(2, 0, Player.Maximizing);
game.State.SetCell(0, 1, Player.Maximizing);
game.State.SetCell(1, 1, Player.Minimizing);
game.State.SetCell(2, 1, null);
game.State.SetCell(0, 2, Player.Minimizing);
game.State.SetCell(1, 2, null);
game.State.SetCell(2, 2, Player.Maximizing);
game.State.NextMovePlayer = Player.Minimizing;
EngineResult aiResult = _ai.Analyse(game);
Assert.AreEqual(Estimate.Zero, aiResult.Estimate, "it should be draw game estimate");
var bestMove = aiResult.BestMove as TicTacToeMove;
Assert.AreEqual(2, bestMove.X, "x");
Assert.AreEqual(1, bestMove.Y, "y");
}
public override EngineResult Analyse(Game game)
{
var result = new EngineResult();
Metadata metadata = new Metadata();
Estimate estimate = default(Estimate);
TimeSpan elapsed = Time.It(() =>
{
estimate = FindImpl(
game: game,
alpha: Estimate.MinInf,
beta: Estimate.MaxInf,
depth: 1,
maxDepth: MaxDepth,
meta: metadata);
});
Debug.Assert(metadata.BestMove != null);
result.BestMove = metadata.BestMove;
result.Estimate = estimate;
result.Metadata.MovesChecked = metadata.MovesChecked;
result.Metadata.ElapsedSec = elapsed.TotalSeconds;
result.Metadata.Rate = metadata.MovesChecked / elapsed.TotalSeconds;
return(result);
}
public List <EngineResult> Process(string contents, string filename)
{
var result = new EngineResult {
FileName = filename
};
var properties = new Dictionary <string, object>();
properties["css"] = contents;
const string script = @"
var exports = require('http://csslint.net/js/csslint.js', null, 'exports.CSSLint = CSSLint;');
var CSSLint = exports.CSSLint;
var css = external.Get('css');
var result = CSSLint.verify(css);
for(var i = 0; i < result.messages.length; i++)
{
var message = result.messages[i];
var messageText = message.message + ': ' + message.evidence;
external.LogMessage(messageText, message.line, message.col);
}
";
var javascriptResult = JavascriptRunner.Execute(script, properties);
result.Exceptions.AddRange(javascriptResult.Messages);
return(new List <EngineResult> {
result
});
}
List <EngineResult> IEngine.Process(string contents, string filename)
{
var result = new EngineResult {
FileName = filename, Extension = "min.js"
};
var properties = new Dictionary <string, object>();
properties["js"] = contents;
const string script = @"
var uglify = require('https://raw.github.com/mishoo/UglifyJS/master/uglify-js.js');
var js = external.Get('js');
var result = uglify(js);
external.Set('result', result);
";
try
{
var javascriptResult = JavascriptRunner.Execute(script, properties);
result.Contents = javascriptResult.Get("result") as string;
result.Exceptions.AddRange(javascriptResult.Messages);
}
catch (ChirpyException cex)
{
result.Exceptions.Add(cex);
}
return(new List <EngineResult> {
result
});
}
public IEngineResult Execute(BadModel model)
{
EngineResult result = new EngineResult()
{
Name = GetType().ToString()
};
return(result);
}
public TxResult(StObject tx, StObject meta, Uint32 ledgerIndex)
{
Tx = tx;
Meta = meta;
LedgerIndex = ledgerIndex;
Hash = tx[Field.hash];
Result = meta[Field.TransactionResult];
TxIndex = meta[Field.TransactionIndex];
Type = tx[Field.TransactionType];
}
public IEngineResult Execute(ExampleModel model)
{
EngineResult result = new EngineResult()
{
Name = GetType().ToString()
};
model.DivisionResult = (float)model.Value1 / model.Value2;
return(result);
}
public IEngineResult Execute(ExampleModel model)
{
EngineResult result = new EngineResult()
{
Name = GetType().ToString()
};
model.MultiplicaionResult = model.Value1 * model.Value2;
return(result);
}
public IEngineResult Execute(ExampleModel model)
{
EngineResult result = new EngineResult()
{
Name = GetType().ToString()
};
model.SubtractResult = model.Value1 - model.Value2;
return(result);
}
public IEngineResult Execute(TestModel model)
{
EngineResult result = new EngineResult()
{
Name = GetType().ToString()
};
model.Result = model.A + model.B;
return(result);
}
public void ConstructorTest()
{
EngineResult result = new EngineResult() { Error = "error", Message = "Message", TimeEnd = DateTime.UtcNow, TimeStart = DateTime.UtcNow};
Assert.IsNotNull(result);
Assert.IsNotNull(result.Error);
Assert.IsNotNull(result.Message);
Assert.IsNotNull(result.TimeEnd);
Assert.IsNotNull(result.TimeStart);
Assert.IsTrue(result.HasError);
}
public IEngineResult Execute(ExampleModel model)
{
EngineResult result = new EngineResult()
{
TimeStart = DateTime.UtcNow, Name = GetType().ToString()
};
model.DivisionResult = (float)model.Value1 / model.Value2;
result.TimeEnd = DateTime.UtcNow;
return(result);
}
public IEngineResult Execute(ExampleModel model)
{
EngineResult result = new EngineResult()
{
TimeStart = DateTime.UtcNow, Name = GetType().ToString()
};
model.SubtractResult = model.Value1 - model.Value2;
result.TimeEnd = DateTime.UtcNow;
return(result);
}
public TxSubmission(Hash256 hash,
EngineResult engineResult,
JObject txJson,
JObject resultJson)
{
Hash = hash;
EngineResult = engineResult;
TxJson = txJson;
ResultJson = resultJson;
ExpectedFinalResult = null;
}
public static EngineResult Evaluate(WhileStatement loop, Scope scope)
{
EngineResult result = null;
while (Evaluate(loop.Predicate, NullArgument.It, scope))
{
result = Evaluate(loop.Statement, scope);
}
return(result);
}
public void ConstructorTest()
{
EngineResult result = new EngineResult()
{
Error = "error", Message = "Message", TimeEnd = DateTime.UtcNow, TimeStart = DateTime.UtcNow
};
Assert.IsNotNull(result);
Assert.IsNotNull(result.Error);
Assert.IsNotNull(result.Message);
Assert.IsNotNull(result.TimeEnd);
Assert.IsNotNull(result.TimeStart);
Assert.IsTrue(result.HasError);
}
public void ConstructorTest()
{
IEngineResult result = new EngineResult()
{
Error = "error", Message = "Message"
}.End();
Assert.IsNotNull(result);
Assert.IsNotNull(result.Error);
Assert.IsNotNull(result.Message);
Assert.IsNotNull(result.TimeEnd);
Assert.IsNotNull(result.TimeStart);
Assert.IsNotNull(result.Elapsed);
Assert.IsTrue(result.HasError);
}
public IList<EngineResult> GetEngineResults(string keyword, int pageIndex = 0, int sleepSeconds = 0)
{
var html = GetHtml(keyword, pageIndex, sleepSeconds);
if (!html.Contains("id=\"ires\""))
throw new InvalidDataException("не найден контент с результатами");
html = html.Substring(html.IndexOf("id=\"ires\""));
var result = new List<EngineResult>();
int position = 0;
int startIndex;
while ((startIndex = html.Substring(position).IndexOf("<li class=\"g\">")) >= 0)
{
const string endTag = "</li>";
var endIndex = html.Substring(position + startIndex).IndexOf(endTag);
if (endIndex == -1)
break;
endIndex += endTag.Length;
var engineResult = new EngineResult
{
ItemHtml = html.Substring(position + startIndex, endIndex)
};
position += startIndex + endIndex;
if (engineResult.ItemHtml.IndexOf("Картинки по запросу", StringComparison.CurrentCultureIgnoreCase) != -1 || //картинки по запросу
engineResult.ItemHtml.IndexOf("<cite class=\"kv\">") != -1 || //видео по запросу
engineResult.ItemHtml.IndexOf("float:right") != -1 //из гугл мапс объекты
)
continue;
try
{
engineResult.Title = GetTitle(engineResult.ItemHtml);
engineResult.Url = GetUrl(engineResult.ItemHtml);
result.Add(engineResult);
}
catch (Exception e)
{
//todo писать в лог
}
}
return result;
}
public void OneMoveToWinTheGame()
{
var game = TicTacToeGame.Classic;
game.State.SetCell(1, 1, Player.Maximizing);
game.State.SetCell(2, 0, Player.Maximizing);
game.State.NextMovePlayer = Player.Maximizing;
EngineResult aiResult = _ai.Analyse(game);
TicTacToeMove bestMove = aiResult.BestMove as TicTacToeMove;
Assert.AreEqual(0, bestMove.X);
Assert.AreEqual(2, bestMove.Y);
}
private PreviewResult ToPreviewResult(EngineResult engineResult)
{
PreviewResult previewResult = new PreviewResult();
previewResult.PreviewStatus = PreviewStatus.Success;
previewResult.EngineStatus = engineResult.EngineStatus;
previewResult.Output = engineResult.Output;
if (engineResult.EngineStatus != EngineStatus.Success)
{
previewResult.PreviewStatus = PreviewStatus.EngineSaysNo;
previewResult.EngineCompileErrors = engineResult.CompileErrors;
previewResult.EngineRunException = engineResult.RunException;
}
return(previewResult);
}
private TransformResult ToTransformResult(EngineResult engineResult)
{
TransformResult transformResult = new TransformResult();
transformResult.TransformStatus = TransformStatus.Success;
transformResult.EngineStatus = engineResult.EngineStatus;
transformResult.Output = engineResult.Output;
if (engineResult.EngineStatus != EngineStatus.Success)
{
transformResult.TransformStatus = TransformStatus.EngineSaysNo;
transformResult.EngineCompileErrors = engineResult.CompileErrors;
transformResult.EngineRunException = engineResult.RunException;
}
return(transformResult);
}
public EngineResult Calculate(string id, EngineInfo engineInfo)
{
if (string.IsNullOrWhiteSpace(id))
{
throw new System.ArgumentNullException("id");
}
if (engineInfo == null)
{
throw new System.ArgumentNullException("engineInfo");
}
var result = new EngineResult
{
ValueA = "A",
ValueB = "B"
};
return(result);
}
string GetOutputFileName(EngineResult result, string filename, EngineContainer engine)
{
var baseFileName = filename;
if (!string.IsNullOrEmpty(result.FileName))
{
baseFileName = result.FileName;
}
var inputExtension = ExtensionResolver.GetExtensionFromCategory(engine.Category);
if (baseFileName.EndsWith(inputExtension))
{
baseFileName = filename.Substring(0, filename.Length - inputExtension.Length);
}
else
{
baseFileName = FileHandler.GetBaseFileName(baseFileName);
}
return(string.Format("{0}.{1}", baseFileName, result.Extension));
}
protected async Task <TxSubmission> Expect(
EngineResult ter,
Task <TxSubmission> future,
[CallerMemberName] string memberName = "",
[CallerFilePath] string sourceFilePath = "",
[CallerLineNumber] int sourceLineNumber = 0)
{
TxSubmission result;
try
{
result = await future;
}
catch (InvalidOperationException e)
{
throw new UnexpectedEngineResultException(
$"In {memberName} @ {sourceFilePath}:{sourceLineNumber} you " +
$"expected {ter} submit response, got:\n" +
$"{Alias(e.Message)}");
}
if (ter != result.EngineResult)
{
throw new UnexpectedEngineResultException(
$"In {memberName} @ {sourceFilePath}:{sourceLineNumber} you " +
$"expected {ter} submit response, got {result.EngineResult}:\n" +
$"{Alias(result.ResultJson.ToString())}");
}
// For checking the final result
result.ExpectedFinalResult = new ResultExpectation
{
EngineResult = ter,
MemberName = memberName,
SourceFilePath = sourceFilePath,
SourceLineNumber = sourceLineNumber
};
return(result);
}
private async void ButtonStartGame_Click(object sender, RoutedEventArgs e)
{
EngineResult addPlayersResult = await AddPlayersToEnginePlayerList();
if (!addPlayersResult.Succedeed)
{
MessageBox.Show(addPlayersResult.ErrorMessage);
return;
}
EngineResult startGameResult = await engine.StartGame(66);
if (!startGameResult.Succedeed)
{
MessageBox.Show(startGameResult.ErrorMessage);
}
else
{
Game game = new Game(engine);
game.Show();
this.Close();
}
}
public EngineResult Run()
{
foreach (LearningSettings learningSettings in eid.SettingsToRun)
{
resultsBySettings[learningSettings] = new List <SingleRunReport>();
for (int i = 0; i < eid.RunsPerSettings; i++)
{
runCounter++;
List <int> layersVal = BuildLayersVal(learningSettings);
BuildDataSet(layersVal);
INetwork network = CreateNetwork(learningSettings, layersVal);
NormalizeData(network, trainSet, testSet);
CheckIfPerformPCA(network);
learningStrategy = new VSetLearningStrategy(learningSettings);
BackpropagationManager backpropMan = new BackpropagationManager(network, trainSet, testSet);
var learningResult = backpropMan.Run(learningStrategy, learningSettings, this);
NormalizeDataBack(network, trainSet, testSet);
resultsBySettings[learningSettings].Add(new SingleRunReport(
network, DateTime.Now, learningResult, trainSet, testSet));
}
// use train error as criterion to simulate real-life ("we cannot use test set results yet - test set is the future")
resultsBySettings[learningSettings].RemoveHighestValues(
r => r.LearningResult.FinalTrainError, discardCount);
}
EngineResult result = new EngineResult();
result.ResultsBySettings = resultsBySettings;
result.Eid = eid;
result.WorstDiscardedCount = discardCount;
return(result);
}
public void EnsureDrawGameWhenAIvsAI()
{
var game = TicTacToeGame.Classic;
int step = 1;
// play as AI wants till the end
while (!game.State.IsTerminate)
{
Trace.WriteLine($"Step #{step}...");
EngineResult aiResult = _ai.Analyse(game);
game.DoMove(aiResult.BestMove);
// draw game estimation all the way till the end
Assert.IsTrue(aiResult.Estimate.IsCloseTo(Estimate.Zero), $"step {step} -- draw game expected");
step += 1;
}
Assert.IsTrue(game.State.IsTerminate, "it should be terminate state now");
Assert.IsTrue(game.State.StaticEstimate.IsCloseTo(Estimate.Zero), $"draw game expected");
}
public List <EngineResult> Process(string contents, string filename)
{
var result = new EngineResult {
FileName = filename
};
var properties = new Dictionary <string, object>();
properties["js"] = contents;
const string script = @"
var exports = require('https://raw.github.com/jshint/jshint/master/jshint.js', null, '');
var JSHINT = exports.JSHINT;
var js = external.Get('js');
var result = JSHINT(js);
var errors = JSHINT.errors;
external.Set('result', result);
external.Set('errors', errors.length);
if (!result)
{
for (var i = 0; i < errors.length; i++)
{
external.LogWarning((errors[i].reason || '') + ': ' + (errors[i].evidence || ''), errors[i].line || 0, errors[i].character || 0);
}
}
";
var javascriptResult = JavascriptRunner.Execute(script, properties);
result.Exceptions.AddRange(javascriptResult.Messages);
return(new List <EngineResult> {
result
});
}
public static ResumeWord getSearchEngineWinner(AvailableEngines engine, List <SearchResult> data)
{
List <ResumeWord> resume = new List <ResumeWord>();
foreach (SearchResult item in data)
{
EngineResult target = item.res.Find(x => x.engine.ToString() == engine.ToString());
resume.Add(new ResumeWord {
word = item.word,
res = target.result
});
}
ResumeWord currentUpper = resume[0];
foreach (ResumeWord item in resume)
{
if (item.res > currentUpper.res)
{
currentUpper.word = item.word;
currentUpper.res = item.res;
}
}
return(currentUpper);
}
