public void Add(string key, string value) { string dataKey = Attributes.DataKey(key); Attribute attr = new Attribute(dataKey, value); enclosingAttributes.Add(dataKey, attr); }
/// <summary> Returns the query portion of the URL, broken up into individual key/value /// pairs. Does NOT unescape the keys and values. /// </summary> public virtual LinkedHashMap getParameterMap() { LinkedHashMap map; SupportClass.Tokenizer tokens = new SupportClass.Tokenizer(Query, "?&"); //$NON-NLS-1$ // multiply by 2 to create a sufficiently large HashMap map = new LinkedHashMap(tokens.Count * 2); while (tokens.HasMoreTokens()) { String nameValuePair = tokens.NextToken(); String name = nameValuePair; String value = ""; //$NON-NLS-1$ int equalsIndex = nameValuePair.IndexOf('='); if (equalsIndex != -1) { name = nameValuePair.Substring(0, (equalsIndex) - (0)); if (name.Length > 0) { value = nameValuePair.Substring(equalsIndex + 1); } } map.Add(name, value); } return(map); }
public string predictAccentsWithMultiMatches(string sentence, int nResults, bool getWeight = true) { LinkedHashMap <string, double> output = new LinkedHashMap <string, double>(); string @in = Utils.normaliseString(sentence); string lowercaseIn = @in.ToLower(); string[] words = ("0 " + lowercaseIn + " 0").Split(' '); Graph graph = new VariableGraph(); Dictionary <int, string> idxWordMap = new Dictionary <int, string>(); int index = 0; int[] numberP = new int[words.Length]; string[,] possibleChange = new string[words.Length, maxp]; int[,] indices = new int[words.Length, maxp]; int nVertex = 0; index = buildGraph(words, graph, idxWordMap, index, numberP, possibleChange, indices, nVertex); //Yen Algorithm for kShortestPaths YenTopKShortestPathsAlg yenAlg = new YenTopKShortestPathsAlg(graph); List <Accent.KShortestPaths.Model.Path> shortest_paths_list = yenAlg.get_shortest_paths(graph.get_vertex(0), graph.get_vertex(index - 1), nResults); foreach (Accent.KShortestPaths.Model.Path path in shortest_paths_list) { List <BaseVertex> pathVertex = path.get_vertices(); string text = ""; for (int i = 1; i < pathVertex.Count - 1; i++) { BaseVertex vertext = pathVertex[i]; text += idxWordMap[vertext.get_id()] + " "; if (text.Contains("đầm dáng")) { text.Replace("đầm dáng", "đảm đang"); } if (text.Contains("chào bán")) { text = Regex.Replace(text, "chào bán", "chào bạn"); } if (text.Contains("bị đầu tay")) { text = Regex.Replace(text, "bị đầu tay", "bị đau tay"); } if (text.Contains("tay tôi bị đầu")) { text = Regex.Replace(text, "tay tôi bị đầu", "tay tôi bị đau"); } } output.Add(processOutput(@in, text.Trim()), path.get_weight()); } // Không lấy trọng số đo lường cho các trường hợp thêm dấu. if (!getWeight) { return(output.ToString2()); } return(output.ToString()); }
// function GIBBS-ASK(X, e, bn, N) returns an estimate of <b>P</b>(X|e) /** * The GIBBS-ASK algorithm in Figure 14.16. For answering queries given * evidence in a Bayesian Network. * * @param X * the query variables * @param e * observed values for variables E * @param bn * a Bayesian network specifying joint distribution * <b>P</b>(X<sub>1</sub>,...,X<sub>n</sub>) * @param Nsamples * the total number of samples to be generated * @return an estimate of <b>P</b>(X|e) */ public CategoricalDistribution gibbsAsk(RandomVariable[] X, AssignmentProposition[] e, BayesianNetwork bn, int Nsamples) { // local variables: <b>N</b>, a vector of counts for each value of X, // initially zero double[] N = new double[ProbUtil .expectedSizeOfCategoricalDistribution(X)]; // Z, the nonevidence variables in bn Set <RandomVariable> Z = new Set <RandomVariable>( bn.getVariablesInTopologicalOrder()); foreach (AssignmentProposition ap in e) { Z.Remove(ap.getTermVariable()); } // <b>x</b>, the current state of the network, initially copied from e Map <RandomVariable, Object> x = new LinkedHashMap <RandomVariable, Object>(); foreach (AssignmentProposition ap in e) { x.Add(ap.getTermVariable(), ap.getValue()); } // initialize <b>x</b> with random values for the variables in Z foreach (RandomVariable Zi in Z) { x.put(Zi, ProbUtil.randomSample(bn.getNode(Zi), x, randomizer)); } // for j = 1 to N do for (int j = 0; j < Nsamples; j++) { // for each Z<sub>i</sub> in Z do foreach (RandomVariable Zi in Z) { // set the value of Z<sub>i</sub> in <b>x</b> by sampling from // <b>P</b>(Z<sub>i</sub>|mb(Z<sub>i</sub>)) x.put(Zi, ProbUtil.mbRandomSample(bn.getNode(Zi), x, randomizer)); } // Note: moving this outside the previous for loop, // as described in fig 14.6, as will only work // correctly in the case of a single query variable X. // However, when multiple query variables, rare events // will get weighted incorrectly if done above. In case // of single variable this does not happen as each possible // value gets * |Z| above, ending up with the same ratios // when normalized (i.e. its still more efficient to place // outside the loop). // // <b>N</b>[x] <- <b>N</b>[x] + 1 // where x is the value of X in <b>x</b> N[ProbUtil.indexOf(X, x)] += 1.0; } // return NORMALIZE(<b>N</b>) return(new ProbabilityTable(N, X).normalize()); }
public void Add() { IDictionary<string, Player> lhm = new LinkedHashMap<string, Player>(); Fill(lhm); lhm.Add("55555", new Player("55555", "Monde Zondeki")); Assert.AreEqual(7, lhm.Count); }
public void Add() { IDictionary <string, Player> lhm = new LinkedHashMap <string, Player>(); Fill(lhm); lhm.Add("55555", new Player("55555", "Monde Zondeki")); Assert.AreEqual(7, lhm.Count); }
public void GivenASentence_WheAddedToHashTable_ShouldReturnWordFrequency() { string sentence = "to be or not to be"; string[] words = sentence.ToLower().Split(" "); foreach (string word in words) { int value = LinkedHashMap.Get(word); if (value == default) { value = 1; } else value += 1; LinkedHashMap.Add(word, value); } int frequency = LinkedHashMap.Get("to"); Console.WriteLine(LinkedHashMap); Assert.AreEqual(2, frequency); }
// function GIBBS-ASK(X, e, bn, N) returns an estimate of <b>P</b>(X|e) /** * The GIBBS-ASK algorithm in Figure 14.16. For answering queries given * evidence in a Bayesian Network. * * @param X * the query variables * @param e * observed values for variables E * @param bn * a Bayesian network specifying joint distribution * <b>P</b>(X<sub>1</sub>,...,X<sub>n</sub>) * @param Nsamples * the total number of samples to be generated * @return an estimate of <b>P</b>(X|e) */ public CategoricalDistribution gibbsAsk(RandomVariable[] X, AssignmentProposition[] e, BayesianNetwork bn, int Nsamples) { // local variables: <b>N</b>, a vector of counts for each value of X, // initially zero double[] N = new double[ProbUtil .expectedSizeOfCategoricalDistribution(X)]; // Z, the nonevidence variables in bn Set<RandomVariable> Z = new Set<RandomVariable>( bn.getVariablesInTopologicalOrder()); foreach (AssignmentProposition ap in e) { Z.Remove(ap.getTermVariable()); } // <b>x</b>, the current state of the network, initially copied from e Map<RandomVariable, Object> x = new LinkedHashMap<RandomVariable, Object>(); foreach (AssignmentProposition ap in e) { x.Add(ap.getTermVariable(), ap.getValue()); } // initialize <b>x</b> with random values for the variables in Z foreach (RandomVariable Zi in Z) { x.put(Zi, ProbUtil.randomSample(bn.getNode(Zi), x, randomizer)); } // for j = 1 to N do for (int j = 0; j < Nsamples; j++) { // for each Z<sub>i</sub> in Z do foreach (RandomVariable Zi in Z) { // set the value of Z<sub>i</sub> in <b>x</b> by sampling from // <b>P</b>(Z<sub>i</sub>|mb(Z<sub>i</sub>)) x.put(Zi, ProbUtil.mbRandomSample(bn.getNode(Zi), x, randomizer)); } // Note: moving this outside the previous for loop, // as described in fig 14.6, as will only work // correctly in the case of a single query variable X. // However, when multiple query variables, rare events // will get weighted incorrectly if done above. In case // of single variable this does not happen as each possible // value gets * |Z| above, ending up with the same ratios // when normalized (i.e. its still more efficient to place // outside the loop). // // <b>N</b>[x] <- <b>N</b>[x] + 1 // where x is the value of X in <b>x</b> N[ProbUtil.indexOf(X, x)] += 1.0; } // return NORMALIZE(<b>N</b>) return new ProbabilityTable(N, X).normalize(); }
private void AddColumnWithValueOrType(string columnName, object valueOrType) { if (columns.ContainsKey(columnName)) { throw new ArgumentException( $"The column '{columnName}' has already been added in this SQL builder", nameof(columnName)); } columns.Add(columnName, valueOrType); }
/// <summary> /// </summary> /// <param name="sym"></param> /// <exception cref="ArgumentException"></exception> public virtual void Define(ISymbol sym) { if (symbols.ContainsKey(sym.GetName())) { throw new ArgumentException("duplicate symbol " + sym.GetName()); } sym.SetScope(this); sym.SetInsertionOrderNumber(symbols.Count); // set to insertion position from 0 symbols.Add(sym.GetName(), sym); }
public static LinkedHashMap <TB, TA> ReverseHashMap <TA, TB>(this LinkedHashMap <TA, TB> map) { var reverseMap = new LinkedHashMap <TB, TA>(); foreach (var pair in map) { reverseMap.Add(pair.Value, pair.Key); } return(reverseMap); }
// TODO: implement fullyReadInputStream //public static void fullyReadInputStream(InputStream is, ByteArrayOutputStream bytes) //{ // final byte[] // buffer = new byte[0x10000]; // try // { // for (; ; ) // { // int read = is.read(buffer); // if (read < 0) // { // break; // } // bytes.write(buffer, 0, read); // } // } // finally // { // is.close(); // } //} public static LinkedHashMap <B, A> reverseHashMap <A, B>(LinkedHashMap <A, B> map) { LinkedHashMap <B, A> reverseMap = new LinkedHashMap <B, A>(); foreach (A a in map.Keys) { B b = map[a]; reverseMap.Add(b, a); } return(reverseMap); }
// function WEIGHTED-SAMPLE(bn, e) returns an event and a weight /** * The WEIGHTED-SAMPLE function in Figure 14.15. * * @param e * observed values for variables E * @param bn * a Bayesian network specifying joint distribution * <b>P</b>(X<sub>1</sub>,...,X<sub>n</sub>) * @return return <b>x</b>, w - an event with its associated weight. */ public Pair <Map <RandomVariable, Object>, Double> weightedSample( BayesianNetwork bn, AssignmentProposition[] e) { // w <- 1; double w = 1.0; // <b>x</b> <- an event with n elements initialized from e Map <RandomVariable, Object> x = new LinkedHashMap <RandomVariable, Object>(); foreach (AssignmentProposition ap in e) { x.Add(ap.getTermVariable(), ap.getValue()); } // foreach variable X<sub>i</sub> in X<sub>1</sub>,...,X<sub>n</sub> do foreach (RandomVariable Xi in bn.getVariablesInTopologicalOrder()) { // if X<sub>i</sub> is an evidence variable with value x<sub>i</sub> // in e if (x.ContainsKey(Xi)) { // then w <- w * P(X<sub>i</sub> = x<sub>i</sub> | // parents(X<sub>i</sub>)) w *= bn.getNode(Xi) .getCPD() .getValue( ProbUtil.getEventValuesForXiGivenParents( bn.getNode(Xi), x)); } else { // else <b>x</b>[i] <- a random sample from // <b>P</b>(X<sub>i</sub> | parents(X<sub>i</sub>)) x.Add(Xi, ProbUtil.randomSample(bn.getNode(Xi), x, randomizer)); } } // return <b>x</b>, w return(new Pair <Map <RandomVariable, Object>, Double>(x, w)); }
// function PRIOR-SAMPLE(bn) returns an event sampled from the prior // specified by bn /** * The PRIOR-SAMPLE algorithm in Figure 14.13. A sampling algorithm that * generates events from a Bayesian network. Each variable is sampled * according to the conditional distribution given the values already * sampled for the variable's parents. * * @param bn * a Bayesian network specifying joint distribution * <b>P</b>(X<sub>1</sub>,...,X<sub>n</sub>) * @return an event sampled from the prior specified by bn */ public Map<RandomVariable, Object> priorSample(BayesianNetwork bn) { // x <- an event with n elements Map<RandomVariable, Object> x = new LinkedHashMap<RandomVariable, Object>(); // foreach variable X<sub>i</sub> in X<sub>1</sub>,...,X<sub>n</sub> do foreach (RandomVariable Xi in bn.getVariablesInTopologicalOrder()) { // x[i] <- a random sample from // <b>P</b>(X<sub>i</sub> | parents(X<sub>i</sub>)) x.Add(Xi, ProbUtil.randomSample(bn.getNode(Xi), x, randomizer)); } // return x return x; }
// function PRIOR-SAMPLE(bn) returns an event sampled from the prior // specified by bn /** * The PRIOR-SAMPLE algorithm in Figure 14.13. A sampling algorithm that * generates events from a Bayesian network. Each variable is sampled * according to the conditional distribution given the values already * sampled for the variable's parents. * * @param bn * a Bayesian network specifying joint distribution * <b>P</b>(X<sub>1</sub>,...,X<sub>n</sub>) * @return an event sampled from the prior specified by bn */ public Map <RandomVariable, Object> priorSample(BayesianNetwork bn) { // x <- an event with n elements Map <RandomVariable, Object> x = new LinkedHashMap <RandomVariable, Object>(); // foreach variable X<sub>i</sub> in X<sub>1</sub>,...,X<sub>n</sub> do foreach (RandomVariable Xi in bn.getVariablesInTopologicalOrder()) { // x[i] <- a random sample from // <b>P</b>(X<sub>i</sub> | parents(X<sub>i</sub>)) x.Add(Xi, ProbUtil.randomSample(bn.getNode(Xi), x, randomizer)); } // return x return(x); }
public void OrderShouldBePreserved() { var items = new[] { KeyValuePair.Create(1, "One"), KeyValuePair.Create(3, "Three"), KeyValuePair.Create(2, "Two"), }; var linkedHashMap = new LinkedHashMap <int, string>(); foreach (var item in items) { linkedHashMap.Add(item); } using var enumerator = linkedHashMap.GetEnumerator(); enumerator.MoveNext(); Assert.AreEqual(1, enumerator.Current.Key); enumerator.MoveNext(); Assert.AreEqual(3, enumerator.Current.Key); enumerator.MoveNext(); Assert.AreEqual(2, enumerator.Current.Key); Assert.True(!enumerator.MoveNext()); var num = 0; foreach (var item in linkedHashMap) { Assert.AreEqual(items[num++], item); } linkedHashMap[1] = "OneAgain"; num = 0; foreach (var item in linkedHashMap) { if (num == 2) { Assert.AreEqual(1, item.Key); } else { Assert.AreEqual(items[num + 1], item); } num++; } }
/// <summary> /// Reloads the internal SPI list. /// Changes to the service list are visible after the method ends, all /// iterators (e.g, from <see cref="AvailableServices"/>,...) stay consistent. /// /// <para/><b>NOTE:</b> Only new service providers are added, existing ones are /// never removed or replaced. /// /// <para/><em>this method is expensive and should only be called for discovery /// of new service providers on the given classpath/classloader!</em> /// </summary> public void Reload() { lock (this) { IDictionary <string, Type> services = new LinkedHashMap <string, Type>(this.services); SPIClassIterator <S> loader = SPIClassIterator <S> .Get(); foreach (var service in loader) { string clazzName = service.Name; string name = null; foreach (string suffix in suffixes) { if (clazzName.EndsWith(suffix, StringComparison.Ordinal)) { name = clazzName.Substring(0, clazzName.Length - suffix.Length).ToLowerInvariant(); break; } } if (name == null) { throw new InvalidOperationException("The class name " + service.Name + " has wrong suffix, allowed are: " + Arrays.ToString(suffixes)); } // only add the first one for each name, later services will be ignored // this allows to place services before others in classpath to make // them used instead of others // // LUCENETODO: Should we disallow duplicate names here? // Allowing it may get confusing on collisions, as different packages // could contain same factory class, which is a naming bug! // When changing this be careful to allow reload()! if (!services.ContainsKey(name)) { services.Add(name, service); } } this.services = Collections.UnmodifiableMap(services); } }
// function WEIGHTED-SAMPLE(bn, e) returns an event and a weight /** * The WEIGHTED-SAMPLE function in Figure 14.15. * * @param e * observed values for variables E * @param bn * a Bayesian network specifying joint distribution * <b>P</b>(X<sub>1</sub>,...,X<sub>n</sub>) * @return return <b>x</b>, w - an event with its associated weight. */ public Pair<Map<RandomVariable, Object>, Double> weightedSample( BayesianNetwork bn, AssignmentProposition[] e) { // w <- 1; double w = 1.0; // <b>x</b> <- an event with n elements initialized from e Map<RandomVariable, Object> x = new LinkedHashMap<RandomVariable, Object>(); foreach (AssignmentProposition ap in e) { x.Add(ap.getTermVariable(), ap.getValue()); } // foreach variable X<sub>i</sub> in X<sub>1</sub>,...,X<sub>n</sub> do foreach (RandomVariable Xi in bn.getVariablesInTopologicalOrder()) { // if X<sub>i</sub> is an evidence variable with value x<sub>i</sub> // in e if (x.ContainsKey(Xi)) { // then w <- w * P(X<sub>i</sub> = x<sub>i</sub> | // parents(X<sub>i</sub>)) w *= bn.getNode(Xi) .getCPD() .getValue( ProbUtil.getEventValuesForXiGivenParents( bn.getNode(Xi), x)); } else { // else <b>x</b>[i] <- a random sample from // <b>P</b>(X<sub>i</sub> | parents(X<sub>i</sub>)) x.Add(Xi, ProbUtil.randomSample(bn.getNode(Xi), x, randomizer)); } } // return <b>x</b>, w return new Pair<Map<RandomVariable, Object>, Double>(x, w); }
public void setAttribute(string key, string value) { azzert(key != "style"); attributes.Add(key, value); }
public void setStyle(string key, string value) { style.Add(key, value); }
public void Performance() { // Take care with this test because the result is not the same every times int numOfRuns = 4; int numOfEntries = Int16.MaxValue; long[] dictPopulateTicks = new long[numOfRuns]; long[] dictItemTicks = new long[numOfRuns]; long[] linkPopulateTicks = new long[numOfRuns]; long[] linkItemTicks = new long[numOfRuns]; for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { string key; object value; IDictionary<string, object> dictionary = new Dictionary<string, object>(); IDictionary<string, object> linked = new LinkedHashMap<string, object>(); long dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { dictionary.Add("test" + i, new object()); } dictPopulateTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = dictionary[key]; } dictItemTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictionary.Clear(); long linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { linked.Add("test" + i, new object()); } linkPopulateTicks[runIndex] = DateTime.Now.Ticks - linkStart; linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = linked[key]; } linkItemTicks[runIndex] = DateTime.Now.Ticks - linkStart; linked.Clear(); } for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { decimal linkPopulateOverhead = (linkPopulateTicks[runIndex] / (decimal)dictPopulateTicks[runIndex]); decimal linkItemOverhead = (linkItemTicks[runIndex] / (decimal)dictItemTicks[runIndex]); string message = string.Format("LinkedHashMap vs Dictionary (Run-{0}) :",runIndex+1); message += "\n POPULATE:"; message += "\n\t linked took " + linkPopulateTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictPopulateTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkPopulateOverhead; message += "\n RETRIVE:"; message += "\n\t linked took " + linkItemTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictItemTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkItemOverhead; Console.Out.WriteLine(message); Console.Out.WriteLine(); } }
/** * Iterate over all possible values assignments for the Random Variables * comprising this ProbabilityTable that are not in the fixed set of values. * This allows you to iterate over a subset of possible combinations. * * @param pti * the ProbabilityTable Iterator to iterate * @param fixedValues * Fixed values for a subset of the Random Variables comprising * this Probability Table. */ public void iterateOverTable(Factor.Iterator pti, params AssignmentProposition[] fixedValues) { Map<RandomVariable, Object> possibleWorld = new LinkedHashMap<RandomVariable, Object>(); MixedRadixNumber tableMRN = new MixedRadixNumber(0, radices); int[] tableRadixValues = new int[radices.Length]; // Assert that the Random Variables for the fixed values // are part of this probability table and assign // all the fixed values to the possible world. foreach (AssignmentProposition ap in fixedValues) { if (!randomVarInfo.ContainsKey(ap.getTermVariable())) { throw new ArgumentException("Assignment proposition [" + ap + "] does not belong to this probability table."); } possibleWorld.Add(ap.getTermVariable(), ap.getValue()); RVInfo fixedRVI = randomVarInfo.get(ap.getTermVariable()); tableRadixValues[fixedRVI.getRadixIdx()] = fixedRVI .getIdxForDomain(ap.getValue()); } // If have assignments for all the random variables // in this probability table if (fixedValues.Length == randomVarInfo.Count) { // Then only 1 iteration call is required. pti.iterate(possibleWorld, getValue(fixedValues)); } else { // Else iterate over the non-fixed values List<RandomVariable> freeVariables = SetOps.difference( new List<RandomVariable>(randomVarInfo.Keys), new List<RandomVariable>(possibleWorld.Keys)); Map<RandomVariable, RVInfo> freeVarInfo = new LinkedHashMap<RandomVariable, RVInfo>(); // Remove the fixed Variables foreach (RandomVariable fv in freeVariables) { freeVarInfo.put(fv, new RVInfo(fv)); } int[] freeRadixValues = createRadixs(freeVarInfo); MixedRadixNumber freeMRN = new MixedRadixNumber(0, freeRadixValues); Object fval = null; // Iterate through all combinations of the free variables do { // Put the current assignments for the free variables // into the possible world and update // the current index in the table MRN foreach (RVInfo freeRVI in freeVarInfo.values()) { fval = freeRVI.getDomainValueAt(freeMRN .getCurrentNumeralValue(freeRVI.getRadixIdx())); possibleWorld.put(freeRVI.getVariable(), fval); tableRadixValues[randomVarInfo.get(freeRVI.getVariable()) .getRadixIdx()] = freeRVI.getIdxForDomain(fval); } pti.iterate(possibleWorld, values[(int) tableMRN .getCurrentValueFor(tableRadixValues)]); } while (freeMRN.increment()); } }
/** * Iterate over all possible values assignments for the Random Variables * comprising this ProbabilityTable that are not in the fixed set of values. * This allows you to iterate over a subset of possible combinations. * * @param pti * the ProbabilityTable Iterator to iterate * @param fixedValues * Fixed values for a subset of the Random Variables comprising * this Probability Table. */ public void iterateOverTable(Factor.Iterator pti, params AssignmentProposition[] fixedValues) { Map <RandomVariable, Object> possibleWorld = new LinkedHashMap <RandomVariable, Object>(); MixedRadixNumber tableMRN = new MixedRadixNumber(0, radices); int[] tableRadixValues = new int[radices.Length]; // Assert that the Random Variables for the fixed values // are part of this probability table and assign // all the fixed values to the possible world. foreach (AssignmentProposition ap in fixedValues) { if (!randomVarInfo.ContainsKey(ap.getTermVariable())) { throw new ArgumentException("Assignment proposition [" + ap + "] does not belong to this probability table."); } possibleWorld.Add(ap.getTermVariable(), ap.getValue()); RVInfo fixedRVI = randomVarInfo.get(ap.getTermVariable()); tableRadixValues[fixedRVI.getRadixIdx()] = fixedRVI .getIdxForDomain(ap.getValue()); } // If have assignments for all the random variables // in this probability table if (fixedValues.Length == randomVarInfo.Count) { // Then only 1 iteration call is required. pti.iterate(possibleWorld, getValue(fixedValues)); } else { // Else iterate over the non-fixed values List <RandomVariable> freeVariables = SetOps.difference( new List <RandomVariable>(randomVarInfo.Keys), new List <RandomVariable>(possibleWorld.Keys)); Map <RandomVariable, RVInfo> freeVarInfo = new LinkedHashMap <RandomVariable, RVInfo>(); // Remove the fixed Variables foreach (RandomVariable fv in freeVariables) { freeVarInfo.put(fv, new RVInfo(fv)); } int[] freeRadixValues = createRadixs(freeVarInfo); MixedRadixNumber freeMRN = new MixedRadixNumber(0, freeRadixValues); Object fval = null; // Iterate through all combinations of the free variables do { // Put the current assignments for the free variables // into the possible world and update // the current index in the table MRN foreach (RVInfo freeRVI in freeVarInfo.values()) { fval = freeRVI.getDomainValueAt(freeMRN .getCurrentNumeralValue(freeRVI.getRadixIdx())); possibleWorld.put(freeRVI.getVariable(), fval); tableRadixValues[randomVarInfo.get(freeRVI.getVariable()) .getRadixIdx()] = freeRVI.getIdxForDomain(fval); } pti.iterate(possibleWorld, values[(int)tableMRN .getCurrentValueFor(tableRadixValues)]); } while (freeMRN.increment()); } }
public void Performance() { // Take care with this test because the result is not the same every times int numOfRuns = 4; int numOfEntries = Int16.MaxValue; long[] dictPopulateTicks = new long[numOfRuns]; long[] dictItemTicks = new long[numOfRuns]; long[] linkPopulateTicks = new long[numOfRuns]; long[] linkItemTicks = new long[numOfRuns]; for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { string key; object value; IDictionary <string, object> dictionary = new Dictionary <string, object>(); IDictionary <string, object> linked = new LinkedHashMap <string, object>(); long dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { dictionary.Add("test" + i, new object()); } dictPopulateTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = dictionary[key]; } dictItemTicks[runIndex] = DateTime.Now.Ticks - dictStart; dictionary.Clear(); long linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { linked.Add("test" + i, new object()); } linkPopulateTicks[runIndex] = DateTime.Now.Ticks - linkStart; linkStart = DateTime.Now.Ticks; for (int i = 0; i < numOfEntries; i++) { key = "test" + i; value = linked[key]; } linkItemTicks[runIndex] = DateTime.Now.Ticks - linkStart; linked.Clear(); } for (int runIndex = 0; runIndex < numOfRuns; runIndex++) { decimal linkPopulateOverhead = (linkPopulateTicks[runIndex] / (decimal)dictPopulateTicks[runIndex]); decimal linkItemOverhead = (linkItemTicks[runIndex] / (decimal)dictItemTicks[runIndex]); string message = string.Format("LinkedHashMap vs Dictionary (Run-{0}) :", runIndex + 1); message += "\n POPULATE:"; message += "\n\t linked took " + linkPopulateTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictPopulateTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkPopulateOverhead; message += "\n RETRIVE:"; message += "\n\t linked took " + linkItemTicks[runIndex] + " ticks."; message += "\n\t dictionary took " + dictItemTicks[runIndex] + " ticks."; message += "\n\t for an overhead of " + linkItemOverhead; Console.Out.WriteLine(message); Console.Out.WriteLine(); } }
void InitFanTable() { canvas = new Canvas(); canvas.Height = chart._contents.ActualHeight; canvas.Width = chart._contents.ActualWidth; canvas.MouseEnter += Canvas_MouseEvent; canvas.MouseMove += Canvas_MouseEvent; canvas.MouseLeave += Canvas_MouseEvent; Rectangle rect = new Rectangle(); rect.Width = chart._contents.ActualWidth; rect.Height = chart._contents.ActualHeight; rect.Fill = new SolidColorBrush(Colors.White); rect.Opacity = 0.01; canvas.Children.Add(rect); //Init Lines line = new LineGraph(); line.Description = "Fan"; line.Stroke = new SolidColorBrush(Colors.Black); line.StrokeThickness = 1; //Init TD points foreach (TD point in fanTable.points) { var btn = new Rectangle(); btn.Width = 15; btn.Height = 15; btn.Stroke = new SolidColorBrush(Colors.Black); btn.Fill = new SolidColorBrush(Colors.White); btn.AddHandler(FrameworkElement.MouseDownEvent, new MouseButtonEventHandler(Btn_MouseDown)); btn.AddHandler(FrameworkElement.MouseUpEvent, new MouseButtonEventHandler(Btn_MouseUp)); btn.AddHandler(FrameworkElement.MouseMoveEvent, new MouseEventHandler(Btn_MouseMove)); setButtonPos(btn, point); canvas.Children.Add(btn); Btns.Add(btn, point); } updateLine(); Config config = SingleInstanceManager.Instance.cfg; //Init FanTable Settings setting_panel = new StackPanel(); setting_panel.Margin = new Thickness(2); //Fixed checkbox CheckBox isFixed = new CheckBox(); isFixed.Click += IsFixed_Click; isFixed.IsChecked = fanTable.isFixed; isFixed.Content = "isFixed"; TextBlock tooltip = new TextBlock(); tooltip.Text = "Set if the FanTable Auto Change Duty base on the circuit power"; isFixed.ToolTip = tooltip; ToolTipService.SetShowDuration(isFixed, 10000); setting_panel.Children.Add(isFixed); //Cpu proportion TextBlock Desc = new TextBlock(); Desc.Text = "Cpu"; setting_panel.Children.Add(Desc); //TextBox TextBox prop = new TextBox(); prop.Name = "Cpu"; prop.Text = fanTable.CpuProportion.ToString(); prop.LostFocus += Prop_LostFocus; tooltip = new TextBlock(); tooltip.Text = "Set the proportion it takes when calc Fan Duty"; prop.ToolTip = tooltip; ToolTipService.SetShowDuration(prop, 10000); setting_panel.Children.Add(prop); if (config.GpuCount >= 1) { //Gpu_1 proportion Desc = new TextBlock(); Desc.Text = "Gpu 1"; setting_panel.Children.Add(Desc); //TextBox prop = new TextBox(); prop.Name = "Gpu_1"; prop.Text = fanTable.Gpu_1_Proportion.ToString(); prop.LostFocus += Prop_LostFocus; tooltip = new TextBlock(); tooltip.Text = "Set the proportion it takes when calc Fan Duty"; prop.ToolTip = tooltip; ToolTipService.SetShowDuration(prop, 10000); setting_panel.Children.Add(prop); } if (config.GpuCount == 2) { //Gpu_2 proportion Desc = new TextBlock(); Desc.Text = "Gpu 2"; setting_panel.Children.Add(Desc); //TextBox prop = new TextBox(); prop.Name = "Gpu_2"; prop.Text = fanTable.Gpu_2_Proportion.ToString(); prop.LostFocus += Prop_LostFocus; tooltip = new TextBlock(); tooltip.Text = "Set the proportion it takes when calc Fan Duty"; prop.ToolTip = tooltip; ToolTipService.SetShowDuration(prop, 5000); setting_panel.Children.Add(prop); } //Starting Duty Desc = new TextBlock(); Desc.Text = "Starting\nDuty"; setting_panel.Children.Add(Desc); //TextBox prop = new TextBox(); prop.Name = "StartingDuty"; prop.Text = fanTable.StartingDuty.ToString(); prop.LostFocus += Prop_LostFocus; tooltip = new TextBlock(); tooltip.Text = "Set the fan starting duty"; prop.ToolTip = tooltip; ToolTipService.SetShowDuration(prop, 10000); setting_panel.Children.Add(prop); }