public void TestInitialize()
{
_scorer = Substitute.For <IScorer>();
_recogniser = new Recogniser <int>(42, _scorer);
var img = new Bitmap(TuningParams.ImageSize, TuningParams.ImageSize);
}
public ComponentManager(IScorer scorer)
{
this.scorer = scorer;
state = new ComponentManagerState
{
};
}
protected double GetFragmentScore(int seqIndex, int modIndex, IScorer scorer, double?[][] nodeScore, double?[][] maxScore)
{
var score = maxScore[seqIndex][modIndex];
if (score != null)
{
return((double)score);
}
var node = _graph[seqIndex][modIndex];
var curNodeScore = nodeScore[seqIndex][modIndex] ??
(nodeScore[seqIndex][modIndex] = scorer.GetFragmentScore(GetComplementaryComposition(seqIndex, modIndex), GetComposition(seqIndex, modIndex)));
var prevNodeScore = 0.0;
if (node.GetPrevNodeIndices().Any())
{
prevNodeScore =
node.GetPrevNodeIndices()
.Max(prevNodeIndex => GetFragmentScore(seqIndex - 1, prevNodeIndex, scorer, nodeScore, maxScore));
}
maxScore[seqIndex][modIndex] = curNodeScore + prevNodeScore;
// ReSharper disable PossibleInvalidOperationException
return((double)maxScore[seqIndex][modIndex]);
// ReSharper restore PossibleInvalidOperationException
}
private void Initialize()
{
if (_isInitialized)
{
return;
}
ReloadSettings();
var gazePointDataProvider = TobiiHost.GetInstance().GetGazePointDataProvider();
gazePointDataProvider.Start(_identifier.GetInstanceID());
if (Scorer == null)
{
//Scorer = new SingleRayCastNoScore();
Scorer = new SingleRaycastHistoricHitScore();
//Scorer = new MultiRaycastHistoricHitScore();
}
if (_multiScorer == null)
{
_multiScorer = new MultiRaycastHistoricHitScore();
}
_isInitialized = true;
}
public OnlineServer(IScorer scorer,
ILog log,
string mapName)
{
this.scorer = scorer;
this.mapName = mapName;
this.log = log.Log;
}
public GreedyEdgeChooserPunterWithStupidZergRush(
IScorer scorer,
IGraphVisitor graphVisitor
)
{
this.scorer = scorer;
this.graphVisitor = graphVisitor;
}
public Component(Node node, Node[] mines, IScorer scorer)
{
Id = Guid.NewGuid();
Nodes = new List <Node> {
node
};
Score = new ComponentScore(node, mines, scorer);
}
internal void Initialize(IndexNode node, IIndexNavigatorPool pool, IScorer scorer)
{
this.pool = pool;
this.scorer = scorer;
this.currentNode = node;
this.intraNodeTextPosition = 0;
this.navigatedWith.Length = 0;
}
public GreedyEdgeChooserPunter(
IScorer scorer,
IGraphVisitor graphVisitor
)
{
this.scorer = scorer;
this.graphVisitor = graphVisitor;
}
public BargeHauler3(
IScorer scorer,
IGraphVisitor graphVisitor
)
{
this.scorer = scorer;
this.graphVisitor = graphVisitor;
}
public Game(IEnumerable <IPlayer> players, IScorer scorer, uint rounds)
{
_Players = players;
_Scorer = scorer;
// Initialise the players
_Scorer.Start(_Players);
_Rounds = rounds;
_Round = 0;
}
public FriendshipPunter(IScorer scorer)
{
this.scorer = scorer;
graphVisitor = new GraphVisitor();
componentManager = new ComponentManager(scorer);
state = new PunterState
{
};
}
/// <summary>
/// Prevents a default instance of the <see cref="Engine" /> class from being created.
/// </summary>
private Engine()
{
this.consoleDrawer = new ConsoleRenderer();
this.consoleReader = new ConsoleInput();
this.inputHandler = new InputHandler(this.consoleDrawer, this.consoleReader);
this.mineFactory = new MineCreator();
this.highscore = new HighScore();
this.finalScore = InitialScore;
}
/// <summary>
/// Get the fragment score at the provided sequence index and mod index, using the provided scorer
/// </summary>
/// <param name="seqIndex"></param>
/// <param name="modIndex"></param>
/// <param name="scorer"></param>
/// <param name="nodeScore"></param>
/// <param name="maxScore"></param>
/// <returns></returns>
protected double GetFragmentScore(int seqIndex, int modIndex, IScorer scorer, double?[][] nodeScore, double?[][] maxScore)
{
var score = maxScore[seqIndex][modIndex];
if (score != null)
{
return((double)score);
}
var node = _graph[seqIndex][modIndex];
double?curNodeScore;
if (nodeScore[seqIndex][modIndex] != null)
{
curNodeScore = nodeScore[seqIndex][modIndex];
}
else
{
var prefixFragmentComposition = GetComplementaryComposition(seqIndex, modIndex);
var suffixFragmentComposition = GetComposition(seqIndex, modIndex);
if (scorer == null)
{
Console.WriteLine("Null scorer");
curNodeScore = 0;
}
else
{
nodeScore[seqIndex][modIndex] = scorer.GetFragmentScore(prefixFragmentComposition,
suffixFragmentComposition);
curNodeScore = nodeScore[seqIndex][modIndex];
}
}
var prevNodeScore = 0.0;
if (node.GetPrevNodeIndices().Any())
{
foreach (var previousNode in node.GetPrevNodeIndices())
{
if (seqIndex == 0)
{
continue;
}
var prevScore = GetFragmentScore(seqIndex - 1, previousNode, scorer, nodeScore, maxScore);
if (prevScore > prevNodeScore)
{
prevNodeScore = prevScore;
}
}
}
maxScore[seqIndex][modIndex] = curNodeScore + prevNodeScore;
// ReSharper disable PossibleInvalidOperationException
return((double)maxScore[seqIndex][modIndex]);
// ReSharper restore PossibleInvalidOperationException
}
public BetStrategyService(IGameRepository gameRepository, IBetRepository betRepository, IStrategyRepository strategyRepository,
IStrategyFactory strategyFactory, IRankingRepository rankingRepository, IScorer scorer)
{
this._gameRepository = gameRepository;
this._betRepository = betRepository;
this._strategyRepository = strategyRepository;
this._strategyFactory = strategyFactory;
this._rankingRepository = rankingRepository;
this._scorer = scorer;
}
public BetStrategyService(IGameRepository gameRepository, IBetRepository betRepository, IStrategyRepository strategyRepository,
IStrategyFactory strategyFactory,IRankingRepository rankingRepository, IScorer scorer)
{
this._gameRepository = gameRepository;
this._betRepository = betRepository;
this._strategyRepository = strategyRepository;
this._strategyFactory = strategyFactory;
this._rankingRepository = rankingRepository;
this._scorer = scorer;
}
public Level(IScorer score, int winScore)
{
score.Updated += (sender, args) =>
{
if (args.Score >= winScore)
{
OnWon(new WonArgs());
}
};
}
public void OneTimeSetUp()
{
_Scorer = new SimpleScorer();
// No need to set a strategy
_Players = new SimplePlayer[] {
new SimplePlayer(@"Player 1", new RandomStrategy(null)),
new SimplePlayer(@"Player 2", new RandomStrategy(null)),
new SimplePlayer(@"Player 3", new RandomStrategy(null))
};
}
/// <summary>
/// Initializes a new instance of the <see cref="CitySearchEngine" /> class
/// </summary>
/// <param name="searchDataRepository">The search data repository</param>
/// <param name="indexedSearchDataRepository">The indexed data repository</param>
/// <param name="queryScorer">The query scorer</param>
/// <param name="locationScorer">The location scorer</param>
public CitySearchEngine(
ISearchDataRepository searchDataRepository,
IIndexedSearchDataRepository indexedSearchDataRepository,
IScorer <string> queryScorer,
IScorer <LocationInformation> locationScorer)
{
this.searchDataRepository = searchDataRepository;
this.indexedSearchDataRepository = indexedSearchDataRepository;
this.queryScorer = queryScorer;
this.locationScorer = locationScorer;
}
public GameService(IGameRepository gameRepository, IBetRepository betRepository, IRankingRepository rankingRepository, IScorer scorer)
{
if (gameRepository == null) throw new ArgumentNullException("gameRepository");
if (betRepository == null) throw new ArgumentNullException("betRepository");
if (scorer == null) throw new ArgumentNullException("scorer");
this._gameRepository = gameRepository;
this._betRepository = betRepository;
this._rankingRepository = rankingRepository;
this._scorer = scorer;
}
public ComponentScore(Node node, Node[] mines, IScorer scorer)
{
Mines = new[] { node }.Where(x => x.IsMine).ToList();
Scores = new Dictionary <int, long>();
foreach (var mine in mines)
{
var d = scorer.GetDistance(mine, node);
Scores.Add(mine.Id, d * d);
}
SelfScore = Mines.Sum(x => Scores[x.Id]);
}
public Component(Node node, Node[] mines, IScorer scorer)
{
Nodes = new List <Node> {
node
};
Mines = Nodes.Where(x => x.IsMine).ToList();
foreach (var mine in mines)
{
var d = scorer.GetDistance(mine, node);
Scores.Add(mine.Id, d * d);
}
}
public void OneTimeSetUp()
{
_Scorer = new SimpleScorer();
var rockPlayer = new SimplePlayer(@"Rock Player", new MockStrategy(HandGesture.Rock));
var paperPlayer = new SimplePlayer(@"Rock Player", new MockStrategy(HandGesture.Paper));
var scissorsPlayer = new SimplePlayer(@"Rock Player", new MockStrategy(HandGesture.Scissors));
_NoPlayers = new IPlayer[] {};
_OnePlayer = new IPlayer[] { rockPlayer };
_TwoPlayers = new IPlayer[] { rockPlayer, paperPlayer };
_ThreePlayers = new IPlayer[] { rockPlayer, paperPlayer, scissorsPlayer };
}
/// <param name="symbol">The symbol which the given scorer is optimised for</param>
/// <param name="scorer">An object which is trained to recognise the symbol specified by the <c>symbol</c> param</param>
public Recogniser(TSymbol symbol, IScorer scorer)
{
if (symbol == null)
{
throw new ArgumentNullException(nameof(symbol));
}
if (scorer == null)
{
throw new ArgumentNullException(nameof(scorer));
}
this.Symbol = symbol;
_scorer = scorer;
}
public AbPruningAi(PieceType player,
int maxDepth,
IScorer scorer,
IMoveEnumerator moveEnumerator,
IBoardFactory boardFactory,
IJudge judge)
{
this.player = player;
this.maxDepth = maxDepth;
this.scorer = scorer;
this.moveEnumerator = moveEnumerator;
this.boardFactory = boardFactory;
this.judge = judge;
}
/// <summary>
/// Get the fragment score at the provided sequence index and mod index, using the provided scorer
/// </summary>
/// <param name="seqIndex"></param>
/// <param name="modIndex"></param>
/// <param name="scorer"></param>
/// <param name="nodeScore"></param>
/// <param name="maxScore"></param>
/// <returns></returns>
protected double GetFragmentScore(int seqIndex, int modIndex, IScorer scorer, double?[][] nodeScore, double?[][] maxScore)
{
var score = maxScore[seqIndex][modIndex];
if (score != null)
{
return((double)score);
}
var node = _graph[seqIndex][modIndex];
/*double? curNodeScore;
*
* if (nodeScore[seqIndex][modIndex] != null)
* {
* curNodeScore = nodeScore[seqIndex][modIndex];
* }
* else
* {
* var prefixFragmentComposition = GetComplementaryComposition(seqIndex, modIndex);
* var suffixFragmentComposition = GetComposition(seqIndex, modIndex);
*
* if (scorer == null)
* {
* ConsoleMsgUtils.ShowWarning("Null scorer in GetFragmentScore");
* curNodeScore = 0;
* }
* else
* {
* nodeScore[seqIndex][modIndex] = scorer.GetFragmentScore(prefixFragmentComposition,
* suffixFragmentComposition);
* curNodeScore = nodeScore[seqIndex][modIndex];
* }
* }*/
var curNodeScore = nodeScore[seqIndex][modIndex] ??
(nodeScore[seqIndex][modIndex] = scorer.GetFragmentScore(GetComplementaryComposition(seqIndex, modIndex), GetComposition(seqIndex, modIndex)));
var prevNodeScore = 0.0;
if (node.GetPrevNodeIndices().Any() && seqIndex > 0)
{
prevNodeScore = node.GetPrevNodeIndices().Max(previousNode => GetFragmentScore(seqIndex - 1, previousNode, scorer, nodeScore, maxScore));
}
maxScore[seqIndex][modIndex] = curNodeScore + prevNodeScore;
// ReSharper disable PossibleInvalidOperationException
return((double)maxScore[seqIndex][modIndex]);
// ReSharper restore PossibleInvalidOperationException
}
public void WonPoint(string playerName)
{
if (playerName == scorer.PlayerOneName)
{
scorer = scorer.PlayerOneWin();
return;
}
if (playerName == scorer.PlayerTwoName)
{
scorer = scorer.PlayerTwoWin();
return;
}
throw new InvalidOperationException($"Unknown player name: {playerName}");
}
/// <summary>
/// Get the score for a protein or peptide sequence.
/// </summary>
/// <param name="scorer">The scorer.</param>
/// <param name="sequence">The sequence.</param>
/// <returns>The score calculated from the sequence.</returns>
public static double ScoreSequence(IScorer scorer, Sequence sequence)
{
var prefixCompositions = GetCompositions(sequence, true);
var suffixCompositions = GetCompositions(sequence, false);
suffixCompositions.Reverse();
var score = 0.0;
for (var i = 0; i < prefixCompositions.Count; i++)
{
score += scorer.GetFragmentScore(prefixCompositions[i], suffixCompositions[i]);
}
return(score);
}
public CardGame(CardGameCommands commands, IPlayerCollection players, IDeck deck, IScorer scorer, IVictoryChecker victoryChecker)
{
Guard.AgainstNullDataContainer(commands, nameof(commands));
Guard.AgainstNull(players, nameof(players));
Guard.AgainstNull(deck, nameof(deck));
Guard.AgainstNull(scorer, nameof(scorer));
Guard.AgainstNull(victoryChecker, nameof(victoryChecker));
this.drawCardsCommandHandler = commands.DrawCardsCommandHandler;
this.updateScoresCommand = commands.UpdateScoresCommandHandler;
this.handleGameEndCommand = commands.CheckForGameEndCommandHandler;
this.players = players;
this.deck = deck;
this.scorer = scorer;
this.victoryChecker = victoryChecker;
}
public IcScores GetIcScores(IInformedScorer informedScorer, IScorer scorer, string seqStr, Composition composition)
{
var seqGraph = SequenceGraph.CreateGraph(AminoAcidSet, AminoAcid.ProteinNTerm, seqStr, AminoAcid.ProteinCTerm);
if (seqGraph == null)
{
return(null);
}
var bestScore = double.NegativeInfinity;
Tuple <double, string> bestScoreAndModifications = null;
var protCompositions = seqGraph.GetSequenceCompositions();
for (var modIndex = 0; modIndex < protCompositions.Length; modIndex++)
{
seqGraph.SetSink(modIndex);
var protCompositionWithH2O = seqGraph.GetSinkSequenceCompositionWithH2O();
if (!protCompositionWithH2O.Equals(composition))
{
continue;
}
var curScoreAndModifications = seqGraph.GetFragmentScoreAndModifications(scorer);
var curScore = curScoreAndModifications.Item1;
if (!(curScore > bestScore))
{
continue;
}
bestScoreAndModifications = curScoreAndModifications;
bestScore = curScore;
}
if (bestScoreAndModifications == null)
{
return(null);
}
var modifications = bestScoreAndModifications.Item2;
var sequence = Sequence.CreateSequence(seqStr, modifications, this.AminoAcidSet);
var numMatchedFragments = informedScorer.GetNumMatchedFragments(sequence);
var score = informedScorer.GetUserVisibleScore(sequence);
return(new IcScores(numMatchedFragments, score, modifications));
}
/// <summary>
/// Get the fragment score and string-format modifications of this sequence graph
/// </summary>
/// <param name="scorer"></param>
/// <returns></returns>
public Tuple <double, string> GetFragmentScoreAndModifications(IScorer scorer)
{
var nodeScore = new double?[_maxSeqIndex][];
var maxScore = new Tuple <double, string> [_maxSeqIndex][];
for (var si = 0; si < _maxSeqIndex; si++)
{
nodeScore[si] = new double?[_graph[si].Length];
maxScore[si] = new Tuple <double, string> [_graph[si].Length];
}
maxScore[0][0] = new Tuple <double, string>(0.0, "");
nodeScore[_index][_sinkModIndex] = 0.0;
var fragmentScore = GetFragmentScoreAndModifications(_index, _sinkModIndex, scorer, nodeScore, maxScore);
return(new Tuple <double, string>(fragmentScore.Item1, fragmentScore.Item2));
}
/// <summary>
/// Get the fragment score using the provided scorer
/// </summary>
/// <param name="scorer"></param>
/// <returns></returns>
public double GetFragmentScore(IScorer scorer)
{
var nodeScore = new double?[_maxSeqIndex][];
var maxScore = new double?[_maxSeqIndex][];
for (var si = 0; si < _maxSeqIndex; si++)
{
nodeScore[si] = new double?[_graph[si].Length];
maxScore[si] = new double?[_graph[si].Length];
}
maxScore[0][0] = 0.0;
nodeScore[_index][_sinkModIndex] = 0.0;
var fragmentScore = GetFragmentScore(_index, _sinkModIndex, scorer, nodeScore, maxScore);
return(fragmentScore);
}
public TagMatchFinder(
ProductSpectrum spec,
IScorer ms2Scorer,
LcMsPeakMatrix featureFinder,
string proteinSequence,
Tolerance tolerance,
AminoAcidSet aaSet,
double maxSequenceMass)
{
_spec = spec;
_ms2Scorer = ms2Scorer;
_featureFinder = featureFinder;
_proteinSequence = proteinSequence;
_tolerance = tolerance;
_aaSet = aaSet;
_maxSequenceMass = maxSequenceMass;
}
private Tuple<double, string> GetFragmentScoreAndModifications(int seqIndex, int modIndex, IScorer scorer, double?[][] nodeScore, Tuple<double, string>[][] maxScoreAndMods)
{
var scoreAndMods = maxScoreAndMods[seqIndex][modIndex];
if (scoreAndMods != null) return scoreAndMods;
var node = _graph[seqIndex][modIndex];
var curNodeScore = nodeScore[seqIndex][modIndex] ??
(nodeScore[seqIndex][modIndex] = scorer.GetFragmentScore(GetComplementaryComposition(seqIndex, modIndex), GetComposition(seqIndex, modIndex)));
var bestPrevNodeIndex = -1;
var bestPrevNodeScore = double.NegativeInfinity;
string bestPrevSequence = null;
foreach (var prevNodeIndex in node.GetPrevNodeIndices())
{
var prevNodeScoreAndSequence = GetFragmentScoreAndModifications(seqIndex - 1, prevNodeIndex, scorer,
nodeScore, maxScoreAndMods);
var prevNodeScore = prevNodeScoreAndSequence.Item1;
if (prevNodeScore > bestPrevNodeScore)
{
bestPrevNodeIndex = prevNodeIndex;
bestPrevNodeScore = prevNodeScore;
bestPrevSequence = prevNodeScoreAndSequence.Item2;
}
}
if (bestPrevNodeIndex < 0) // source
{
return maxScoreAndMods[seqIndex][modIndex] = new Tuple<double, string>((double)curNodeScore, "");
}
var modPos = _index - seqIndex;
var aminoAcid = _aminoAcidSequence[seqIndex];
var modAa = aminoAcid as ModifiedAminoAcid;
if (modAa != null)
{
var modificationName = modAa.Modification.Name;
if (string.IsNullOrEmpty(bestPrevSequence))
{
bestPrevSequence = modificationName + " " + modPos;
}
else
{
bestPrevSequence = modificationName + " " + modPos + "," + bestPrevSequence;
}
}
var prevModCombIndex = _graph[seqIndex - 1][bestPrevNodeIndex].ModificationCombinationIndex;
var curModCombIndex = node.ModificationCombinationIndex;
if (prevModCombIndex != curModCombIndex) // modified
{
var modificationName = ModificationParams.GetModificationIndexBetween(prevModCombIndex, curModCombIndex).Name;
string newModSequence;
if (string.IsNullOrEmpty(bestPrevSequence))
{
newModSequence = modificationName + " " + modPos;
}
else
{
newModSequence = modificationName + " " + modPos + ",";
}
return maxScoreAndMods[seqIndex][modIndex] = new Tuple<double, string>
((double)curNodeScore + bestPrevNodeScore, newModSequence+bestPrevSequence);
}
return maxScoreAndMods[seqIndex][modIndex] = new Tuple<double, string>
((double)curNodeScore + bestPrevNodeScore, bestPrevSequence);
}
public ScoreService(IRepository repository)
{
_repository = repository;
_scorer = new Scorer();
}
void OnScorerScoreChanged(IScorer scorer, float score)
{
l.Trace(scorer.ToString() + " score: " + score);
// if before min change mind time, queue an update for when that time comes
// OPTIMIZE - could cache the current highest score and scorer to see if the highest one dipped (in which case, recalculate highest from all), or if a non-highest one beat the current high score
SelectedChild = GetHighestScore();
}
private IEnumerable<TagSequenceMatch> GetMatches(IEnumerable<SequenceTag> tags, ProductSpectrum spec, IScorer scorer)
{
// Match tags against the database
var proteinsToTags = GetProteinToMatchedTagsMap(tags, _searchableDb, _aaSet, _tolerance, _tolerance);
//var tagSequenceMatchList = new List<TagSequenceMatch>();
// Extend matches
foreach (var entry in proteinsToTags)
{
var proteinName = entry.Key;
var matchedTagSet = entry.Value;
var proteinSequence = matchedTagSet.Sequence;
var tagFinder = new TagMatchFinder(spec, scorer, _featureFinder, proteinSequence, _tolerance, _aaSet, _maxSequenceMass);
foreach (var matchedTag in matchedTagSet.Tags)
{
if (matchedTag.Length < _minMatchedTagLength) continue;
if (matchedTag.NTermFlankingMass == null && matchedTag.CTermFlankingMass == null) continue;
var matches = tagFinder.FindMatches(matchedTag).ToArray();
//var prevScore = double.NegativeInfinity;
//foreach (var match in matches.OrderByDescending(m => m.Score))
foreach(var match in matches)
{
var sequence = proteinSequence.Substring(match.StartIndex, match.EndIndex - match.StartIndex);
//re-scoring
var sequenceObj = Sequence.CreateSequence(sequence, match.ModificationText, _aaSet);
match.Score = sequenceObj.GetInternalCleavages().Sum(c => scorer.GetFragmentScore(c.PrefixComposition, c.SuffixComposition));
//var numMatches = matchedTag.Length * 2 + match.NTermScore + match.CTermScore;
//var score = match.NTermScore + match.CTermScore;
//score += (matchedTag.NumReliableNTermFlankingMasses > 0)
// ? matchedTag.Length*CompositeScorer.ScoreParam.Prefix.ConsecutiveMatch
//: matchedTag.Length*CompositeScorer.ScoreParam.Suffix.ConsecutiveMatch;
// Poisson p-value score
//var n = (match.EndIndex - match.StartIndex - 1)*2;
//var lambda = numMatches / n;
//var pValue = 1 - Poisson.CDF(lambda, numMatches);
//var pScore = (pValue > 0) ? - Math.Log(pValue, 2) : 50.0;
//if (numMatches < 5) break;
//if (prevScore - numMatches > 2) break;
//prevScore = numMatches;
var pre = match.StartIndex == 0 ? '-' : proteinSequence[match.StartIndex - 1]; // startIndex is inclusive
var post = match.EndIndex >= proteinSequence.Length ? '-' : proteinSequence[match.EndIndex]; // endIndex is Exclusive
yield return new TagSequenceMatch(sequence, proteinName, match, pre, post);
//tagSequenceMatchList.Add(new TagSequenceMatch(sequence, proteinName, match, pre, post));
}
}
}
//return tagSequenceMatchList;
}
protected double GetFragmentScore(int seqIndex, int modIndex, IScorer scorer, double?[][] nodeScore, double?[][] maxScore)
{
var score = maxScore[seqIndex][modIndex];
if (score != null) return (double)score;
var node = _graph[seqIndex][modIndex];
var curNodeScore = nodeScore[seqIndex][modIndex] ??
(nodeScore[seqIndex][modIndex] =
_isForward ? scorer.GetFragmentScore(GetComposition(seqIndex, modIndex), GetComplementaryComposition(seqIndex, modIndex))
: scorer.GetFragmentScore(GetComplementaryComposition(seqIndex, modIndex), GetComposition(seqIndex, modIndex))
);
var prevNodeScore = 0.0;
if (node.GetPrevNodeIndices().Any())
{
prevNodeScore =
node.GetPrevNodeIndices()
.Max(prevNodeIndex => GetFragmentScore(seqIndex - 1, prevNodeIndex, scorer, nodeScore, maxScore));
}
maxScore[seqIndex][modIndex] = curNodeScore + prevNodeScore;
// ReSharper disable PossibleInvalidOperationException
return (double)maxScore[seqIndex][modIndex];
// ReSharper restore PossibleInvalidOperationException
}
private Tuple<double, LinkedList<ModificationInstance>> GetFragmentScoreAndModifications(int seqIndex, int modIndex,
IScorer scorer, double?[][] nodeScore, Tuple<double, LinkedList<ModificationInstance>>[][] maxScoreAndMods)
{
var scoreAndMods = maxScoreAndMods[seqIndex][modIndex];
if (scoreAndMods != null) return scoreAndMods;
var node = _graph[seqIndex][modIndex];
var curNodeScore = nodeScore[seqIndex][modIndex] ??
(nodeScore[seqIndex][modIndex] = _isForward
? scorer.GetFragmentScore(GetComposition(seqIndex, modIndex),
GetComplementaryComposition(seqIndex, modIndex))
: scorer.GetFragmentScore(GetComplementaryComposition(seqIndex, modIndex),
GetComposition(seqIndex, modIndex))
);
var bestPrevNodeIndex = -1;
var bestPrevNodeScore = double.NegativeInfinity;
LinkedList<ModificationInstance> bestPrevMods = null;
foreach (var prevNodeIndex in node.GetPrevNodeIndices())
{
var prevNodeScoreAndSequence = GetFragmentScoreAndModifications(seqIndex - 1, prevNodeIndex, scorer,
nodeScore, maxScoreAndMods);
var prevNodeScore = prevNodeScoreAndSequence.Item1;
if (prevNodeScore > bestPrevNodeScore)
{
bestPrevNodeIndex = prevNodeIndex;
bestPrevNodeScore = prevNodeScore;
bestPrevMods = prevNodeScoreAndSequence.Item2;
}
}
if (bestPrevNodeIndex < 0) // source
{
return maxScoreAndMods[seqIndex][modIndex] = new Tuple<double, LinkedList<ModificationInstance>>((double)curNodeScore, new LinkedList<ModificationInstance>());
}
var modPos = _isForward ? seqIndex : _index - seqIndex;
if (modPos <= 1) --modPos;
var aminoAcid = _aminoAcidSequence[seqIndex];
var modAa = aminoAcid as ModifiedAminoAcid;
LinkedList<ModificationInstance> newMods = null;
if (modAa != null)
{
newMods = bestPrevMods == null ? new LinkedList<ModificationInstance>() : new LinkedList<ModificationInstance>(bestPrevMods);
var modIns = new ModificationInstance(modAa.Modification, modPos);
if (_isForward) newMods.AddLast(modIns);
else newMods.AddFirst(modIns);
}
var prevModCombIndex = _graph[seqIndex - 1][bestPrevNodeIndex].ModificationCombinationIndex;
var curModCombIndex = node.ModificationCombinationIndex;
if (prevModCombIndex != curModCombIndex) // modified
{
if (newMods == null)
{
newMods = bestPrevMods == null ? new LinkedList<ModificationInstance>() : new LinkedList<ModificationInstance>(bestPrevMods);
}
var modification = ModificationParams.GetModificationIndexBetween(prevModCombIndex, curModCombIndex);
var modIns = new ModificationInstance(modification, modPos);
if (_isForward) newMods.AddLast(modIns);
else newMods.AddFirst(modIns);
}
return maxScoreAndMods[seqIndex][modIndex] = new Tuple<double, LinkedList<ModificationInstance>>
((double)curNodeScore + bestPrevNodeScore, newMods ?? bestPrevMods);
}
public Tuple<double, LinkedList<ModificationInstance>> GetScoreAndModifications(IScorer scorer)
{
var nodeScore = new double?[_maxSeqIndex][];
var maxScore = new Tuple<double, LinkedList<ModificationInstance>>[_maxSeqIndex][];
for (var si = 0; si <= _index; si++)
{
nodeScore[si] = new double?[_graph[si].Length];
maxScore[si] = new Tuple<double, LinkedList<ModificationInstance>>[_graph[si].Length];
}
maxScore[0][0] = new Tuple<double, LinkedList<ModificationInstance>>(0.0, new LinkedList<ModificationInstance>());
nodeScore[_index][_sinkModIndex] = 0.0;
var fragmentScore = GetFragmentScoreAndModifications(_index, _sinkModIndex, scorer, nodeScore,
maxScore);
return new Tuple<double, LinkedList<ModificationInstance>>(fragmentScore.Item1, fragmentScore.Item2);
}
public double GetFragmentScore(IScorer scorer)
{
var nodeScore = new double?[_maxSeqIndex][];
var maxScore = new double?[_maxSeqIndex][];
for (var si = 0; si <= _index; si++)
{
nodeScore[si] = new double?[_graph[si].Length];
maxScore[si] = new double?[_graph[si].Length];
}
maxScore[0][0] = 0.0;
nodeScore[_index][_sinkModIndex] = 0.0;
var fragmentScore = GetFragmentScore(_index, _sinkModIndex, scorer, nodeScore, maxScore);
return fragmentScore;
}
public void CreateScorer()
{
_scorer = new TenPinScorer();
}
public RankingRepository(IBetRepository betRepository, IScorer scorer)
{
this._betRepository = betRepository;
this._scorer = scorer;
}
