public VariableArray2D <double> GetPopulationForIteration(int Iterations, double CatPopulation, double MousePopulation) { Variable <int> numTimes = Variable.Observed(Iterations); Range time = new Range(numTimes); Range cols = new Range(2); // frist is Cats and second Mice VariableArray2D <double> days = Variable.Array <double>(time, cols); using (ForEachBlock rowBlock = Variable.ForEach(time)) { var day = rowBlock.Index; using (Variable.If(day == 0)) { Cat.SetNewPopulation(CatPopulation); Mouse.SetNewPopulation(MousePopulation); days[day, 0] = Cat.GetPopulation(); days[day, 1] = Mouse.GetPopulation(); } using (Variable.If(day > 0)) { days[day, 0] = days[day - 1, 0] + GetCatPopulationChange(); days[day, 1] = days[day - 1, 1] + GetMousePopulationChange(); } } return(days); }
public void ForNSEW(int x, int y, int z, ForEachBlock predicate) { predicate(X + x - 1, y, Z + z); predicate(X + x + 1, y, Z + z); predicate(X + x, y, Z + z - 1); predicate(X + x, y, Z + z + 1); }
public void PottsGridTest() { int size = 10; Range rows = new Range(size).Named("rows"); Range cols = new Range(size).Named("cols"); var states = Variable.Array <bool>(rows, cols).Named("states"); Bernoulli[,] unary = new Bernoulli[size, size]; for (int i = 0; i < size; i++) { for (int j = 0; j < size; j++) { var xdist = System.Math.Abs(i - size / 2) / ((double)size); var ydist = System.Math.Abs(j - size / 2) / ((double)size); bool inrect = (xdist < 0.2) && (ydist < 0.2); unary[i, j] = new Bernoulli(inrect ? 0.8 : 0.2); } } var p = Variable.Observed(unary, rows, cols); states[rows, cols] = Variable.Random <bool, Bernoulli>(p[rows, cols]); double logCost = 0; using (ForEachBlock rowBlock = Variable.ForEach(rows)) { using (ForEachBlock colBlock = Variable.ForEach(cols)) { using (Variable.If(rowBlock.Index >= 1)) { Variable.Potts(states[rowBlock.Index, colBlock.Index], states[rowBlock.Index + -1, colBlock.Index], logCost); } using (Variable.If(colBlock.Index >= 1)) { Variable.Potts(states[rowBlock.Index, colBlock.Index], states[rowBlock.Index, colBlock.Index + -1], logCost); } } } InferenceEngine engine = new InferenceEngine(); engine.Algorithm = new MaxProductBeliefPropagation(); engine.ShowTimings = true; engine.NumberOfIterations = 20; var result = engine.Infer <Bernoulli[, ]>(states); for (int i = 0; i < result.GetLength(0); i++) { for (int j = 0; j < result.GetLength(1); j++) { Console.Write("{0:f5} ", result[i, j].GetProbTrue()); } Console.WriteLine(); } }
public void ForEach(ForEachBlock predicate) { for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) for (int y = 0; y < 128; y++) predicate(x, y, z); }
public void ForNSEW(UniversalCoords coords, ForEachBlock predicate) { predicate(UniversalCoords.FromWorld(coords.WorldX - 1, coords.WorldY, coords.WorldZ)); predicate(UniversalCoords.FromWorld(coords.WorldX + 1, coords.WorldY, coords.WorldZ)); predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ - 1)); predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ + 1)); }
public void ForAdjacentSameChunk(int x, int y, int z, ForEachBlock predicate) { if (x > 0) { predicate(x - 1, y, z); } if (x < 15) { predicate(x + 1, y, z); } if (y > 0) { predicate(x, y - 1, z); } if (y < 127) { predicate(x, y + 1, z); } if (z > 0) { predicate(x, y, z - 1); } if (z < 15) { predicate(x, y, z + 1); } }
/// <summary> /// Initializes a new instance of the <see cref="MultiPlayer" /> class. /// </summary> /// <param name="parameters">The parameters.</param> /// <param name="showFactorGraph">if set to <c>true</c> [show factor graph].</param> /// <param name="trainingModel">if set to <c>true</c> [training model].</param> public MultiPlayer(IModelParameters parameters, bool showFactorGraph = false, bool trainingModel = true) : base(parameters) { //The factor graph of this model slightly differs from the one from the book //because this model is generic and uses arrays to support any number of players. this.numberOfPlayers = Variable.New <int>().Named("numberOfPlayers").Attrib(new DoNotInfer()); var dynamicsVariance = Variable.Observed(this.Parameters.DynamicsVariance).Named("dynamicsVariance"); var performanceVariance = Variable.Observed(this.Parameters.PerformanceVariance).Named("performanceVariance"); Range player = new Range(this.numberOfPlayers).Named("player"); this.playersPerGame = Variable.New <int>().Named("playersPerGame").Attrib(new DoNotInfer()); Range gamePlayer = new Range(this.playersPerGame).Named("gamePlayer"); this.skillPriors = Variable.Array <Gaussian>(player).Named("skillPriors").Attrib(new DoNotInfer()); this.skills = Variable.Array <double>(player).Named("skills"); this.skills[player] = Variable.GaussianFromMeanAndVariance(Variable <double> .Random(this.skillPriors[player]), dynamicsVariance); this.drawMargin = Variable.New <double>().Named("drawMargin"); this.drawMarginPrior = Variable.New <Gaussian>().Named("drawMarginPrior"); this.drawMargin.SetTo(Variable <double> .Random(this.drawMarginPrior)); Variable.ConstrainTrue(this.drawMargin > 0); this.playerIndices = Variable.Array <int>(gamePlayer).Named("playerIndices").Attrib(new DoNotInfer()); this.performances = Variable.Array <double>(gamePlayer).Named("performances"); var gameSkills = Variable.Subarray(this.skills, this.playerIndices).Named("gameSkills"); if (trainingModel) { this.scores = Variable.Array <int>(gamePlayer).Named("scores").Attrib(new DoNotInfer()); } using (ForEachBlock gp = Variable.ForEach(gamePlayer)) { this.performances[gamePlayer] = Variable.GaussianFromMeanAndVariance(gameSkills[gamePlayer], performanceVariance); if (trainingModel) { using (Variable.If(gp.Index > 0)) { var diff = (this.performances[gp.Index - 1] - this.performances[gp.Index]).Named("diff"); using (Variable.If(this.scores[gp.Index - 1] == this.scores[gp.Index])) { Variable.ConstrainBetween(diff, -this.drawMargin, this.drawMargin); } using (Variable.IfNot(this.scores[gp.Index - 1] == this.scores[gp.Index])) { Variable.ConstrainTrue(diff > this.drawMargin); } } } } this.engine = Utils.GetDefaultEngine(showFactorGraph); }
static void Main(string[] args) { /* Original data with missing values * int[] disaster_data = new int[] {4, 5, 4, 0, 1, 4, 3, 4, 0, 6, 3, 3, 4, 0, 2, 6, * 3, 3, 5, 4, 5, 3, 1, 4, 4, 1, 5, 5, 3, 4, 2, 5, * 2, 2, 3, 4, 2, 1, 3, -999, 2, 1, 1, 1, 1, 3, 0, 0, * 1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1, * 0, 1, 0, 1, 0, 0, 0, 2, 1, 0, 0, 0, 1, 1, 0, 2, * 3, 3, 1, -999, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4, * 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1 }; */ int[] disaster_data = { 4, 5, 4, 0, 1, 4, 3, 4, 0, 6, 3, 3, 4, 0, 2, 6, 3, 3, 5, 4, 5, 3, 1, 4, 4, 1, 5, 5, 3, 4, 2, 5, 2, 2, 3, 4, 2, 1, 3, 2, 2, 1, 1, 1, 1, 3, 0, 0, 1, 0, 1, 1, 0, 0, 3, 1, 0, 3, 2, 2, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 2, 1, 0, 0, 0, 1, 1, 0, 2, 3, 3, 1, 2, 2, 1, 1, 1, 1, 2, 4, 2, 0, 0, 1, 4, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1 }; Range n = new Range(disaster_data.Length).Named("years_idx"); var switchpoint = Variable.DiscreteUniform(n.Clone()).Named("switchpoint"); switchpoint.Name = nameof(switchpoint); var data = Variable.Array <int>(n).Named("data"); using (Variable.Switch(switchpoint)) { var early_rate = Variable.GammaFromShapeAndRate(2.0, 2.0).Named("early_rate"); var late_rate = Variable.GammaFromShapeAndRate(2.0, 2.0).Named("late_rate"); using (ForEachBlock block = Variable.ForEach(n)) { using (Variable.If(switchpoint > block.Index)) data[n] = Variable.Poisson(early_rate); using (Variable.IfNot(switchpoint > block.Index)) data[n] = Variable.Poisson(late_rate); } } data.ObservedValue = disaster_data; InferenceEngine engine = new InferenceEngine(); engine.Compiler.GenerateInMemory = false; engine.Compiler.WriteSourceFiles = true; engine.Compiler.IncludeDebugInformation = true; var switchpointMarginal = engine.Infer <Discrete>(switchpoint); Console.WriteLine(switchpointMarginal); Console.ReadKey(); }
public void ForAdjacent(int x, int y, int z, ForEachBlock predicate) { predicate(X + x - 1, y, Z + z); predicate(X + x + 1, y, Z + z); predicate(X + x, y, Z + z - 1); predicate(X + x, y, Z + z + 1); if (y > 0) predicate(X + x, y - 1, Z + z); if (y < 127) predicate(X + x, y + 1, Z + z); }
public void ForAdjacent(UniversalCoords coords, ForEachBlock predicate) { predicate(UniversalCoords.FromWorld(coords.WorldX - 1, coords.WorldY, coords.WorldZ)); predicate(UniversalCoords.FromWorld(coords.WorldX + 1, coords.WorldY, coords.WorldZ)); predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ - 1)); predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY, coords.WorldZ + 1)); if (coords.BlockY > 0) predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY - 1, coords.WorldZ)); if (coords.BlockY < 127) predicate(UniversalCoords.FromWorld(coords.WorldX, coords.WorldY + 1, coords.WorldZ)); }
public void ForEach(ForEachBlock predicate) { for (int x = 0; x < 16; x++) { for (int z = 0; z < 16; z++) { for (int y = 0; y < 128; y++) { predicate(x, y, z); } } } }
public void ForAdjacent(int x, int y, int z, ForEachBlock predicate) { int chunkWorldX = (X << 4); int chunkWorldZ = (Z << 4); predicate(chunkWorldX + x - 1, y, chunkWorldZ + z); predicate(chunkWorldX + x + 1, y, chunkWorldZ + z); predicate(chunkWorldX + x, y, chunkWorldZ + z - 1); predicate(chunkWorldX + x, y, chunkWorldZ + z + 1); if (y > 0) predicate(chunkWorldX + x, y - 1, chunkWorldZ + z); if (y < 127) predicate(chunkWorldX + x, y + 1, chunkWorldZ + z); }
public void ForAdjacentSameChunk(int x, int y, int z, ForEachBlock predicate) { if (x > 0) predicate(x - 1, y, z); if (x < 15) predicate(x + 1, y, z); if (y > 0) predicate(x, y - 1, z); if (y < 127) predicate(x, y + 1, z); if (z > 0) predicate(x, y, z - 1); if (z < 15) predicate(x, y, z + 1); }
private CSharpName GetEarlyExitNameIfRequired(ForEachBlock forEachBlock, ScopeAccessInformation scopeAccessInformation) { if (forEachBlock == null) { throw new ArgumentNullException("forEachBlock"); } if (scopeAccessInformation == null) { throw new ArgumentNullException("scopeAccessInformation"); } if (!forEachBlock.ContainsLoopThatContainsMismatchedExitThatMustBeHandledAtThisLevel()) { return(null); } return(_tempNameGenerator(new CSharpName("exitFor"), scopeAccessInformation)); }
public void ForEach(ForEachBlock predicate) { for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) for (int y = 127; y >=0; --y) predicate(x, y, z); }
/*public void SetAllBlocks(byte[] data) { Types = data; }*/ internal void ForEach(ForEachBlock predicate) { for (int x = 0; x < 16; x++) for (int z = 0; z < 16; z++) for (int y = 127; y >= 0; --y) predicate(UniversalCoords.FromBlock(Coords.ChunkX, Coords.ChunkZ, x, y, z)); }
public void ForNSEW(int x, int y, int z, ForEachBlock predicate) { int chunkWorldX = (X << 4); int chunkWorldZ = (Z << 4); predicate(chunkWorldX + x - 1, y, chunkWorldZ + z); predicate(chunkWorldX + x + 1, y, chunkWorldZ + z); predicate(chunkWorldX + x, y, chunkWorldZ + z - 1); predicate(chunkWorldX + x, y, chunkWorldZ + z + 1); }
public TrainModel(int dimFeatures) { // // Dataset size // numExamples = Variable.New <int>(); example = new Range(numExamples); // // Jagged 1-D arrays of arrays for item scores and features // exampleSize = Variable.Array <int>(example); item = new Range(exampleSize[example]); scores = Variable.Array(Variable.Array <double>(item), example); features = Variable.Array(Variable.Array <Vector>(item), example); // // Jagged 1-D arrays for pairwise item ranks // rankSize = Variable.Array <int>(example); pair = new Range(rankSize[example]); ranks = Variable.Array(Variable.Array <bool>(pair), example); // // Model parameters // w = Variable.VectorGaussianFromMeanAndVariance(Vector.Zero(dimFeatures), PositiveDefiniteMatrix.Identity(dimFeatures)).Named("w"); // // Model // scoresNoise = Variable.GammaFromShapeAndScale(1.0, 3.0); using (Variable.ForEach(example)) { using (Variable.ForEach(item)) { var mean = Variable.InnerProduct(w, features[example][item]); scores[example][item] = Variable.GaussianFromMeanAndPrecision(mean, scoresNoise); } using (ForEachBlock pairBlock = Variable.ForEach(pair)) { var idx = pairBlock.Index; var diff = scores[example][idx + 1] - scores[example][idx]; using (Variable.If(diff > 0)) ranks[example][pair] = true; using (Variable.IfNot(diff > 0)) ranks[example][pair] = false; } } // // Inference engine // engine = new InferenceEngine(); engine.NumberOfIterations = 50; engine.Compiler.UseParallelForLoops = true; }
public virtual void CreateModel(int numGenes) { NumGenes = Variable.New <int>(); NumGenes.ObservedValue = numGenes; Range geneRange = new Range(NumGenes).Named("geneRange"); Range geneWeightRange = new Range(NumGenes - 1).Named("geneWeightRange"); genesT1Prior = Variable.Array <Gaussian>(geneRange).Named("genesT1Prior");; alphaPrior = Variable.Array <Gaussian>(geneRange).Named("alphaPrior");; betaPrior = Variable.Array <Gaussian>(geneRange).Named("betaPrior"); wPrior = Variable.Array(Variable.Array <Gaussian>(geneWeightRange), geneRange).Named("wPrior"); genesT1 = Variable.Array <double>(geneRange).Named("genesT1"); genesT2 = Variable.Array <double>(geneRange).Named("genesT2"); var indicesArray = Variable.Array(Variable.Array <int>(geneWeightRange), geneRange).Named("indicesArray"); //genesT1[geneRange] = Variable.Random<double, Gaussian>(genesT1Prior).ForEach(geneRange); genesT1[geneRange] = Variable <double> .Random(genesT1Prior[geneRange]); int[][] indices = new int[NumGenes.ObservedValue][]; for (int i = 0; i < NumGenes.ObservedValue; i++) { indices[i] = new int[NumGenes.ObservedValue - 1]; int j = 0, ind = 0; while (j < NumGenes.ObservedValue) { if (i == j) { j++; continue; } indices[i][ind] = j; j++; ind++; } } for (int i = 0; i < NumGenes.ObservedValue; i++) { for (int j = 0; j < NumGenes.ObservedValue - 1; j++) { Console.WriteLine(indices[i][j]); } } indicesArray.ObservedValue = indices; alpha = Variable.Array <double>(geneRange).Named("alpha"); beta = Variable.Array <double>(geneRange).Named("beta"); //alpha[geneRange] = Variable.Random<double, Gaussian>(alphaPrior).ForEach(geneRange); alpha[geneRange] = Variable <double> .Random(alphaPrior[geneRange]); //beta[geneRange] = Variable.Random<double, Gaussian>(betaPrior).ForEach(geneRange); beta[geneRange] = Variable <double> .Random(betaPrior[geneRange]); w = Variable.Array(Variable.Array <double>(geneWeightRange), geneRange).Named("w"); w[geneRange][geneWeightRange] = Variable.Random <double, Gaussian>(wPrior[geneRange][geneWeightRange]); // Laplace distribution //w[geneRange][geneWeightRange] = Variable.GaussianFromMeanAndVariance(0, Variable.GammaFromShapeAndRate(1, 1)).ForEach(geneRange, geneWeightRange); VariableArray <double> genesubarray = Variable.Array <double>(geneWeightRange).Named("genesubarray"); using (ForEachBlock firstBlock = Variable.ForEach(geneRange)) { Variable <double> selfEffect = -(alpha[geneRange] * genesT1[geneRange]); VariableArray <double> weightSum = Variable.Array <double>(geneWeightRange).Named("weightSum"); Console.WriteLine("summing " + geneRange + " + " + geneWeightRange); genesubarray = Variable.Subarray(genesT1, indicesArray[geneRange]); weightSum[geneWeightRange] = w[geneRange][geneWeightRange] * genesubarray[geneWeightRange]; //genesT1[geneRange2] Variable <double> othersEffect = beta[geneRange] * Variable.Sum(weightSum); // Variable.Logistic(Variable.Sum(weightSum));// Variable.Sum(weightSum); //Variable.Logistic(innerproduct); genesT2[geneRange] = selfEffect + othersEffect; } if (InferenceEngine == null) { InferenceEngine = new InferenceEngine(); } }
public TranslationResult Translate(ForEachBlock forEachBlock, ScopeAccessInformation scopeAccessInformation, int indentationDepth) { if (forEachBlock == null) { throw new ArgumentNullException("forEachBlock"); } if (scopeAccessInformation == null) { throw new ArgumentNullException("scopeAccessInformation"); } if (indentationDepth < 0) { throw new ArgumentOutOfRangeException("indentationDepth", "must be zero or greater"); } // The approach here is to get an IEnumerator reference and then loop over it in a "while (true)" loop, exiting when there are no more items. It would // feel more natural to use a C# foreach loop but the loop variable may not be restricted in scope to the loop (in fact, in VBScript this is very unlikely) // and so a "Type and identifier are both required in a foreach statement" compile error would result - "foreach (i in a)" is not valid, it must be of the // form "foreach (var i in a)" which only works if "i" is limited in scope to that loop. The "while (true)" structure also works better when error-trapping // may be enabled since the call-MoveNext-and-set-loop-variable-to-enumerator-Current-value-if-not-reached-end-of-data can be bypassed entirely if an error // was caught while evaluating the enumerator (in which case the loop should be processed once but the loop variable not set). // Note: The looped-over content must be of type "Reference" since VBScript won't enumerate over strings, for example, whereas C# would be happy to. // However, to make the output marginally easier to read, the ENUMERABLE method will deal with this logic and so the ExpressionReturnTypeOptions // value passed to the statement translator is "NotSpecified". var loopSourceContent = _statementTranslator.Translate(forEachBlock.LoopSrc, scopeAccessInformation, ExpressionReturnTypeOptions.NotSpecified, _logger.Warning); var undeclaredVariablesInLoopSourceContent = loopSourceContent.GetUndeclaredVariablesAccessed(scopeAccessInformation, _nameRewriter); foreach (var undeclaredVariable in undeclaredVariablesInLoopSourceContent) { _logger.Warning("Undeclared variable: \"" + undeclaredVariable.Content + "\" (line " + (undeclaredVariable.LineIndex + 1) + ")"); } var translationResult = TranslationResult.Empty.AddUndeclaredVariables(undeclaredVariablesInLoopSourceContent); var enumerationContentVariableName = _tempNameGenerator(new CSharpName("enumerationContent"), scopeAccessInformation); var enumeratorInitialisationContent = string.Format( "{0} = {1}.ENUMERABLE({2}).GetEnumerator();", enumerationContentVariableName.Name, _supportRefName.Name, loopSourceContent.TranslatedContent ); if (!scopeAccessInformation.IsDeclaredReference(forEachBlock.LoopVar, _nameRewriter)) { translationResult = translationResult.AddUndeclaredVariables(new[] { forEachBlock.LoopVar }); } var rewrittenLoopVarName = _nameRewriter.GetMemberAccessTokenName(forEachBlock.LoopVar); var loopVarTargetContainer = scopeAccessInformation.GetNameOfTargetContainerIfAnyRequired(forEachBlock.LoopVar, _envRefName, _outerRefName, _nameRewriter); if (loopVarTargetContainer != null) { rewrittenLoopVarName = loopVarTargetContainer.Name + "." + rewrittenLoopVarName; } if (scopeAccessInformation.ErrorRegistrationTokenIfAny == null) { translationResult = translationResult.Add(new TranslatedStatement( "var " + enumeratorInitialisationContent, indentationDepth, forEachBlock.LoopVar.LineIndex )); } else { // If ON ERROR RESUME NEXT wraps a FOR EACH loop and there is an error in evaluating the enumerator, then the loop will be entered once. The // loop variable will not be altered - eg. // // On Error Resume Next // Dim i: For Each i in "12" // WScript.Echo "We're in the loop! i is " & TypeName(i) // Next // // VBScript can not enumerate a string, so the loop errors. But the ON ERROR RESUME NEXT causes the loop to be processed - only once. This is // approached by calling _.ENUMERABLE before the loop construct, setting a temporary variable to be the returned enumerable inside a call to // "HANDLEERROR" - meaning that it will be left as null if it fails. Null values are replaced with a single-item array, where the element is // the current value of the loop variable - so its value is not altered when the loop is entered. // - Note: The "error-trapping" wrapper functions ("HANDLEERROR") are used around code that MAY have error-trapping enabled (there are cases // where we can't know at translation time whether it will have been turned off with ON ERROR GOTO 0 or not - and there are probably some // cases that could be picked up if the translation process was more intelligent). If the above example had an ON ERROR GOTO 0 between the // ON ERROR RESUME NEXT and the FOR EACH loop then the error (about trying to enumerate a string) would be raised and so the FOR EACH would // not be entered, and so the single-element "fallback array" would never come to exist. If errors WERE still being captured, then the // translated FOR EACH loop WOULD be entered and enumerated through once (without the value of the loop variable being altered, as // is consistent with VBScript) translationResult = translationResult .Add(new TranslatedStatement( string.Format( "IEnumerator {0} = null;", enumerationContentVariableName.Name ), indentationDepth, forEachBlock.LoopVar.LineIndex )) .Add(new TranslatedStatement( string.Format( "{0}.HANDLEERROR({1}, () => {{", _supportRefName.Name, scopeAccessInformation.ErrorRegistrationTokenIfAny.Name ), indentationDepth, forEachBlock.LoopVar.LineIndex )) .Add(new TranslatedStatement( enumeratorInitialisationContent, indentationDepth + 1, forEachBlock.LoopVar.LineIndex )) .Add(new TranslatedStatement("});", indentationDepth, forEachBlock.LoopVar.LineIndex)); } translationResult = translationResult .Add(new TranslatedStatement("while (true)", indentationDepth, forEachBlock.LoopVar.LineIndex)) .Add(new TranslatedStatement("{", indentationDepth, forEachBlock.LoopVar.LineIndex)); if (scopeAccessInformation.ErrorRegistrationTokenIfAny != null) { // If error-trapping is enabled and an error was indeed trapped while trying evaluate the enumerator, then the enumerator will be null. // In this case, the loop should be executed once but the loop variable not set to anything. When this happens, there is no point trying // to call MoveNext (since the enumerator is null) and the loop-variable-setting should be skipped. So an is-null check is wrapper around // that work. If error-trapping is not enabled then this check is not required and a level of nesting in the translated output can be // avoided. translationResult = translationResult .Add(new TranslatedStatement( string.Format( "if ({0} != null)", enumerationContentVariableName.Name ), indentationDepth + 1, forEachBlock.LoopVar.LineIndex )) .Add(new TranslatedStatement("{", indentationDepth + 1, forEachBlock.LoopVar.LineIndex)); indentationDepth++; } translationResult = translationResult .Add(new TranslatedStatement(string.Format( "if (!{0}.MoveNext())", enumerationContentVariableName.Name ), indentationDepth + 1, forEachBlock.LoopVar.LineIndex )) .Add(new TranslatedStatement("break;", indentationDepth + 2, forEachBlock.LoopVar.LineIndex)) .Add(new TranslatedStatement( string.Format( "{0} = {1}.Current;", rewrittenLoopVarName, enumerationContentVariableName.Name ), indentationDepth + 1, forEachBlock.LoopVar.LineIndex )); if (scopeAccessInformation.ErrorRegistrationTokenIfAny != null) { // If error-trapping may be enabled then the above MoveNext and set-to-Current work was wrapped in a condition which must be closed translationResult = translationResult.Add(new TranslatedStatement("}", indentationDepth, forEachBlock.LoopVar.LineIndex)); indentationDepth--; } var earlyExitNameIfAny = GetEarlyExitNameIfRequired(forEachBlock, scopeAccessInformation); if (earlyExitNameIfAny != null) { translationResult = translationResult.Add(new TranslatedStatement( string.Format("var {0} = false;", earlyExitNameIfAny.Name), indentationDepth + 1, forEachBlock.LoopVar.LineIndex )); } translationResult = translationResult.Add( Translate( forEachBlock.Statements.ToNonNullImmutableList(), scopeAccessInformation.SetParent(forEachBlock), earlyExitNameIfAny, indentationDepth + 1 ) ); if (scopeAccessInformation.ErrorRegistrationTokenIfAny != null) { // If error-trapping was enabled and an error caught, then the loop should be processed once and only once. The enumerator reference // will be null - so check for that and exit if so. If there is no chance that error-trapping is enabled then this condition is not // required and there is no point emitting it. translationResult = translationResult .Add(new TranslatedStatement( string.Format( "if ({0} == null)", enumerationContentVariableName.Name ), indentationDepth + 1, forEachBlock.LoopVar.LineIndex )) .Add(new TranslatedStatement("break;", indentationDepth + 2, forEachBlock.LoopVar.LineIndex)); } translationResult = translationResult.Add(new TranslatedStatement("}", indentationDepth, forEachBlock.LoopVar.LineIndex)); var earlyExitFlagNamesToCheck = scopeAccessInformation.StructureExitPoints .Where(e => e.ExitEarlyBooleanNameIfAny != null) .Select(e => e.ExitEarlyBooleanNameIfAny.Name); if (earlyExitFlagNamesToCheck.Any()) { // Perform early-exit checks for any scopeAccessInformation.StructureExitPoints - if this is FOR loop inside a DO..LOOP loop and an // EXIT DO was encountered within the FOR that must refer to the containing DO, then the FOR loop will have been broken out of, but // also a flag set that means that we must break further to get out of the DO loop. translationResult = translationResult .Add(new TranslatedStatement( "if (" + string.Join(" || ", earlyExitFlagNamesToCheck) + ")", indentationDepth, forEachBlock.LoopVar.LineIndex )) .Add(new TranslatedStatement( "break;", indentationDepth + 1, forEachBlock.LoopVar.LineIndex )); } return(translationResult); }
public PredictModel() { // // Dataset size // numExamples = Variable.New <int>(); example = new Range(numExamples); // // Jagged arrays for (items, features) // exampleSize = Variable.Array <int>(example); item = new Range(exampleSize[example]); scores = Variable.Array(Variable.Array <double>(item), example); features = Variable.Array(Variable.Array <Vector>(item), example); // // Jagged array for item pair ranks // rankSize = Variable.Array <int>(example); rank = new Range(rankSize[example]); ranks = Variable.Array(Variable.Array <bool>(rank), example); // // Model parameters // wPrior = Variable.New <VectorGaussian>(); w = Variable.Random <Vector, VectorGaussian>(wPrior); // // Model // scoresNoisePrior = Variable.New <Gamma>(); scoresNoise = Variable.Random <double, Gamma>(scoresNoisePrior); using (Variable.ForEach(example)) { using (Variable.ForEach(item)) { var mean = Variable.InnerProduct(w, features[example][item]); scores[example][item] = Variable.GaussianFromMeanAndPrecision(mean, scoresNoise); } using (ForEachBlock pairBlock = Variable.ForEach(rank)) { var idx = pairBlock.Index; var diff = scores[example][idx + 1] - scores[example][idx]; var positiveDiff = diff > 0; using (Variable.If(positiveDiff)) ranks[example][rank].SetTo(Variable.Bernoulli(0.999)); using (Variable.IfNot(positiveDiff)) ranks[example][rank].SetTo(Variable.Bernoulli(0.001)); } } // // Inference engine // engine = new InferenceEngine(); engine.NumberOfIterations = 5; engine.Compiler.UseParallelForLoops = false; }