// 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 virtual void addMultipleRatesContainingEntryWithNoCommonCurrency() { LinkedHashMap <CurrencyPair, double> rates = new LinkedHashMap <CurrencyPair, double>(); rates.put(CurrencyPair.of(GBP, USD), 1.6); rates.put(CurrencyPair.of(EUR, USD), 1.4); rates.put(CurrencyPair.of(JPY, CAD), 0.01); // Neither currency linked to one of the others assertThrows(() => FxMatrix.builder().addRates(rates).build(), typeof(System.InvalidOperationException)); }
static Dch客室利用台帳Dbm() { { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_DB_NAME.ToLower(), TABLE_PROPERTY_NAME); map.put(DB_NAME_id.ToLower(), PROPERTY_NAME_id); map.put(DB_NAME_客室利用コード.ToLower(), PROPERTY_NAME_客室利用コード); map.put(DB_NAME_客室コード.ToLower(), PROPERTY_NAME_客室コード); map.put(DB_NAME_開始予定日時.ToLower(), PROPERTY_NAME_開始予定日時); map.put(DB_NAME_終了予定日時.ToLower(), PROPERTY_NAME_終了予定日時); map.put(DB_NAME_開始実績日時.ToLower(), PROPERTY_NAME_開始実績日時); map.put(DB_NAME_終了実績日時.ToLower(), PROPERTY_NAME_終了実績日時); map.put(DB_NAME_備考.ToLower(), PROPERTY_NAME_備考); _dbNamePropertyNameKeyToLowerMap = map; } { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_PROPERTY_NAME.ToLower(), TABLE_DB_NAME); map.put(PROPERTY_NAME_id.ToLower(), DB_NAME_id); map.put(PROPERTY_NAME_客室利用コード.ToLower(), DB_NAME_客室利用コード); map.put(PROPERTY_NAME_客室コード.ToLower(), DB_NAME_客室コード); map.put(PROPERTY_NAME_開始予定日時.ToLower(), DB_NAME_開始予定日時); map.put(PROPERTY_NAME_終了予定日時.ToLower(), DB_NAME_終了予定日時); map.put(PROPERTY_NAME_開始実績日時.ToLower(), DB_NAME_開始実績日時); map.put(PROPERTY_NAME_終了実績日時.ToLower(), DB_NAME_終了実績日時); map.put(PROPERTY_NAME_備考.ToLower(), DB_NAME_備考); _propertyNameDbNameKeyToLowerMap = map; } }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void loadParReader(java.net.URL specModelURL, String markingStrategy, String coveredRoot) throws org.maltparser.core.exception.MaltChainedException public virtual void loadParReader(URL specModelURL, string markingStrategy, string coveredRoot) { if (specModelURL == null) { throw new FeatureException("The URL to the feature specification model is missing or not well-formed. "); } FeatureSpecReader specReader = null; string urlSuffix = specModelURL.ToString().Substring(specModelURL.ToString().Length - 3); urlSuffix = char.ToUpper(urlSuffix[0]) + urlSuffix.Substring(1); try { Type clazz = Type.GetType("org.maltparser.core.feature.spec.reader." + urlSuffix + "Reader"); specReader = (FeatureSpecReader)global::System.Activator.CreateInstance(clazz); } catch (InstantiationException e) { throw new FeatureException("Could not initialize the feature specification reader to read the specification file: " + specModelURL.ToString(), e); } catch (IllegalAccessException e) { throw new FeatureException("Could not initialize the feature specification reader to read the specification file: " + specModelURL.ToString(), e); } catch (ClassNotFoundException e) { throw new FeatureException("Could not find the feature specification reader to read the specification file: " + specModelURL.ToString(), e); } specReaderMap[specModelURL] = specReader; if (specReader is ParReader) { if (markingStrategy.Equals("head", StringComparison.OrdinalIgnoreCase) || markingStrategy.Equals("path", StringComparison.OrdinalIgnoreCase) || markingStrategy.Equals("head+path", StringComparison.OrdinalIgnoreCase)) { ((ParReader)specReader).Pplifted = true; } if (markingStrategy.Equals("path", StringComparison.OrdinalIgnoreCase) || markingStrategy.Equals("head+path", StringComparison.OrdinalIgnoreCase)) { ((ParReader)specReader).Pppath = true; } if (!coveredRoot.Equals("none", StringComparison.OrdinalIgnoreCase)) { ((ParReader)specReader).PpcoveredRoot = true; } } specModelKeyMap.put(specModelURL, currentSpecModelURL); specReader.load(specModelURL, this); }
//[MethodImpl(MethodImplOptions.Synchronized)] public void put(K key, V value) { lock (this) { map.put(key, value); } }
static Dch月締確定台帳Dbm() { { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_DB_NAME.ToLower(), TABLE_PROPERTY_NAME); map.put(DB_NAME_対象年月.ToLower(), PROPERTY_NAME_対象年月); _dbNamePropertyNameKeyToLowerMap = map; } { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_PROPERTY_NAME.ToLower(), TABLE_DB_NAME); map.put(PROPERTY_NAME_対象年月.ToLower(), DB_NAME_対象年月); _propertyNameDbNameKeyToLowerMap = map; } }
static DmyプロシージャDbm() { { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_DB_NAME.ToLower(), TABLE_PROPERTY_NAME); map.put(DB_NAME_dummy.ToLower(), PROPERTY_NAME_dummy); _dbNamePropertyNameKeyToLowerMap = map; } { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_PROPERTY_NAME.ToLower(), TABLE_DB_NAME); map.put(PROPERTY_NAME_dummy.ToLower(), DB_NAME_dummy); _propertyNameDbNameKeyToLowerMap = map; } }
public void xsetupOuterJoin_Dch客室利用台帳() { Dch客室利用台帳CQ cq = ConditionQueryDch客室利用台帳; Map <String, String> joinOnMap = new LinkedHashMap <String, String>(); joinOnMap.put("客室利用台帳id", "id"); registerOuterJoin(cq, joinOnMap); }
public void xsetupOuterJoin_Mst従業員マスタ() { Mst従業員マスタCQ cq = ConditionQueryMst従業員マスタ; Map <String, String> joinOnMap = new LinkedHashMap <String, String>(); joinOnMap.put("従業員コード", "従業員コード"); registerOuterJoin(cq, joinOnMap); }
public void xsetupOuterJoin_Kbn職位区分() { Kbn職位区分CQ cq = ConditionQueryKbn職位区分; Map <String, String> joinOnMap = new LinkedHashMap <String, String>(); joinOnMap.put("職位コード", "職位コード"); registerOuterJoin(cq, joinOnMap); }
public virtual void addMultipleRates() { // Use linked map to force the order of evaluation // want to see that builder recovers when // encountering a currency pair for 2 unknown // currencies but which will appear later LinkedHashMap <CurrencyPair, double> rates = new LinkedHashMap <CurrencyPair, double>(); rates.put(CurrencyPair.of(GBP, USD), 1.6); rates.put(CurrencyPair.of(EUR, USD), 1.4); rates.put(CurrencyPair.of(CHF, AUD), 1.2); // Neither currency seen before rates.put(CurrencyPair.of(SEK, AUD), 0.16); // AUD seen before but not added yet rates.put(CurrencyPair.of(JPY, CAD), 0.01); // Neither currency seen before rates.put(CurrencyPair.of(EUR, CHF), 1.2); rates.put(CurrencyPair.of(JPY, USD), 0.0084); FxMatrix matrix = FxMatrix.builder().addRates(rates).build(); assertThat(matrix.fxRate(GBP, USD)).isEqualTo(1.6); assertThat(matrix.fxRate(USD, GBP)).isEqualTo(1 / 1.6); assertThat(matrix.fxRate(EUR, USD)).isEqualTo(1.4); assertThat(matrix.fxRate(USD, EUR)).isEqualTo(1 / 1.4); assertThat(matrix.fxRate(EUR, GBP)).isEqualTo(1.4 / 1.6, TOL); assertThat(matrix.fxRate(GBP, EUR)).isEqualTo(1.6 / 1.4, TOL); assertThat(matrix.fxRate(EUR, CHF)).isEqualTo(1.2); }
static Kbn客室利用区分Dbm() { { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_DB_NAME.ToLower(), TABLE_PROPERTY_NAME); map.put(DB_NAME_客室利用コード.ToLower(), PROPERTY_NAME_客室利用コード); map.put(DB_NAME_客室利用名称.ToLower(), PROPERTY_NAME_客室利用名称); _dbNamePropertyNameKeyToLowerMap = map; } { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_PROPERTY_NAME.ToLower(), TABLE_DB_NAME); map.put(PROPERTY_NAME_客室利用コード.ToLower(), DB_NAME_客室利用コード); map.put(PROPERTY_NAME_客室利用名称.ToLower(), DB_NAME_客室利用名称); _propertyNameDbNameKeyToLowerMap = map; } }
static Mst権限マスタDbm() { { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_DB_NAME.ToLower(), TABLE_PROPERTY_NAME); map.put(DB_NAME_職位コード.ToLower(), PROPERTY_NAME_職位コード); map.put(DB_NAME_画面コード.ToLower(), PROPERTY_NAME_画面コード); _dbNamePropertyNameKeyToLowerMap = map; } { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_PROPERTY_NAME.ToLower(), TABLE_DB_NAME); map.put(PROPERTY_NAME_職位コード.ToLower(), DB_NAME_職位コード); map.put(PROPERTY_NAME_画面コード.ToLower(), DB_NAME_画面コード); _propertyNameDbNameKeyToLowerMap = map; } }
/** * @param cb Condition-bean. (NotNull) * @param entity Entity. (NotNull) * @return The two-way SQL of query update. (NullAllowed: If the set of modified properties is empty, return null.) */ protected String buildQueryUpdateTwoWaySql(ConditionBean cb, Entity entity) { Map <String, String> columnParameterMap = new LinkedHashMap <String, String>(); DBMeta dbmeta = DBMetaInstanceHandler.FindDBMeta(entity.TableDbName); System.Collections.Generic.IDictionary <String, Object> modifiedPropertyNames = entity.ModifiedPropertyNames; if (modifiedPropertyNames.Count == 0) { return(null); } String currentPropertyName = null; foreach (String propertyName in modifiedPropertyNames.Keys) { currentPropertyName = propertyName; ColumnInfo columnInfo = dbmeta.FindColumnInfo(propertyName); String columnName = columnInfo.ColumnDbName; PropertyInfo getter = columnInfo.FindProperty(); Object value = getter.GetValue(entity, null); if (value != null) { columnParameterMap.put(columnName, "/*entity." + propertyName + "*/null"); } else { columnParameterMap.put(columnName, "null"); } } if (dbmeta.HasVersionNo) { ColumnInfo columnInfo = dbmeta.VersionNoColumnInfo; String columnName = columnInfo.ColumnDbName; columnParameterMap.put(columnName, columnName + " + 1"); } if (dbmeta.HasUpdateDate) { ColumnInfo columnInfo = dbmeta.UpdateDateColumnInfo; PropertyInfo setter = columnInfo.FindProperty(); setter.SetValue(entity, DateTime.Now, null); String columnName = columnInfo.ColumnDbName; columnParameterMap.put(columnName, "/*entity." + columnInfo.PropertyName + "*/null"); } return(cb.SqlClause.getClauseQueryUpdate(columnParameterMap)); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void add(String subModelName, String featureSpec) throws org.maltparser.core.exception.MaltChainedException public virtual void add(string subModelName, string featureSpec) { if (ReferenceEquals(subModelName, null) || subModelName.Length < 1 || subModelName.ToUpper().Equals("MAIN")) { if (!subModelMap.containsKey("MAIN")) { subModelMap.put("MAIN", new SpecificationSubModel("MAIN")); } subModelMap.get("MAIN").add(featureSpec); } else { if (!subModelMap.containsKey(subModelName.ToUpper())) { subModelMap.put(subModelName.ToUpper(), new SpecificationSubModel(subModelName.ToUpper())); } subModelMap.get(subModelName.ToUpper()).add(featureSpec); } }
public void AddParameterType(InternalProcedureParameterType parameterType) { String name = parameterType.ParameterName; parameterTypeMap.put(name.ToLower(), parameterType); if (parameterType.IsReturnType) { _returnType = parameterType.ParameterPropertyType; } }
private void addNewRate(Currency ccy1, Currency ccy2, double rate) { Currency existing = currencies.containsKey(ccy1) ? ccy1 : ccy2; Currency other = existing == ccy1 ? ccy2 : ccy1; double updatedRate = existing == ccy2 ? 1.0 / rate : rate; int indexRef = currencies.get(existing); int indexOther = currencies.size(); currencies.put(other, indexOther); rates[indexOther][indexOther] = 1.0; for (int i = 0; i < indexOther; i++) { double convertedRate = updatedRate * rates[i][indexRef]; rates[i][indexOther] = convertedRate; rates[indexOther][i] = 1.0 / convertedRate; } }
static Dch宿泊利用台帳Dbm() { { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_DB_NAME.ToLower(), TABLE_PROPERTY_NAME); map.put(DB_NAME_客室利用台帳id.ToLower(), PROPERTY_NAME_客室利用台帳id); map.put(DB_NAME_会員コード.ToLower(), PROPERTY_NAME_会員コード); map.put(DB_NAME_宿泊料金.ToLower(), PROPERTY_NAME_宿泊料金); _dbNamePropertyNameKeyToLowerMap = map; } { Map <String, String> map = new LinkedHashMap <String, String>(); map.put(TABLE_PROPERTY_NAME.ToLower(), TABLE_DB_NAME); map.put(PROPERTY_NAME_客室利用台帳id.ToLower(), DB_NAME_客室利用台帳id); map.put(PROPERTY_NAME_会員コード.ToLower(), DB_NAME_会員コード); map.put(PROPERTY_NAME_宿泊料金.ToLower(), DB_NAME_宿泊料金); _propertyNameDbNameKeyToLowerMap = map; } }
public virtual void addSimpleMultipleRates() { // Use linked to force the order of evaluation // want to see that builder recovers when // encountering a currency pair for 2 unknown // currencies but which will appear later LinkedHashMap <CurrencyPair, double> rates = new LinkedHashMap <CurrencyPair, double>(); rates.put(CurrencyPair.of(GBP, USD), 1.6); rates.put(CurrencyPair.of(EUR, USD), 1.4); FxMatrix matrix = FxMatrix.builder().addRates(rates).build(); assertThat(matrix.fxRate(GBP, USD)).isEqualTo(1.6); assertThat(matrix.fxRate(USD, GBP)).isEqualTo(1 / 1.6); assertThat(matrix.fxRate(EUR, USD)).isEqualTo(1.4); assertThat(matrix.fxRate(USD, EUR)).isEqualTo(1 / 1.4); assertThat(matrix.fxRate(EUR, GBP)).isEqualTo(1.4 / 1.6, TOL); assertThat(matrix.fxRate(GBP, EUR)).isEqualTo(1.6 / 1.4, TOL); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: public void parseParameters(String paramstring, java.util.LinkedHashMap<String, String> libOptions, String allowedLibOptionFlags) throws org.maltparser.core.exception.MaltChainedException public virtual void parseParameters(string paramstring, LinkedHashMap <string, string> libOptions, string allowedLibOptionFlags) { if (ReferenceEquals(paramstring, null)) { return; } //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String[] argv; string[] argv; try { argv = paramstring.Split("[_\\p{Blank}]", true); } catch (PatternSyntaxException e) { throw new LibException("Could not split the parameter string '" + paramstring + "'. ", e); } for (int i = 0; i < argv.Length - 1; i++) { if (argv[i][0] != '-') { throw new LibException("The argument flag should start with the following character '-', not with " + argv[i][0]); } if (++i >= argv.Length) { throw new LibException("The last argument does not have any value. "); } try { int index = allowedLibOptionFlags.IndexOf(argv[i - 1][1]); if (index != -1) { libOptions.put(Convert.ToString(argv[i - 1][1]), argv[i]); } else { throw new LibException("Unknown learner parameter: '" + argv[i - 1] + "' with value '" + argv[i] + "'. "); } } catch (IndexOutOfRangeException e) { throw new LibException("The learner parameter '" + argv[i - 1] + "' could not convert the string value '" + argv[i] + "' into a correct numeric value. ", e); } catch (FormatException e) { throw new LibException("The learner parameter '" + argv[i - 1] + "' could not convert the string value '" + argv[i] + "' into a correct numeric value. ", e); } catch (NullReferenceException e) { throw new LibException("The learner parameter '" + argv[i - 1] + "' could not convert the string value '" + argv[i] + "' into a correct numeric value. ", e); } } }
/** Return map sorted by key */ public LinkedHashMap <K, V> sort <K, V>(Map <K, V> data) { LinkedHashMap <K, V> dup = new LinkedHashMap <K, V>(); IList <K> keys = new List <K>(); keys.addAll(data.keySet()); Collections.sort(keys); foreach (K k in keys) { dup.put(k, data.get(k)); } return(dup); }
/// <summary> /// Splits the array according to the curve order. /// <para> /// The input array must be of the same size as the total number of parameters. /// The result consists of a map of arrays, where each array is the appropriate /// section of the input array as defined by the curve order. /// /// </para> /// </summary> /// <param name="array"> the array to split </param> /// <returns> a map splitting the array by curve name </returns> public IDictionary <CurveName, DoubleArray> splitValues(DoubleArray array) { LinkedHashMap <CurveName, DoubleArray> result = new LinkedHashMap <CurveName, DoubleArray>(); int start = 0; foreach (CurveParameterSize paramSizes in order) { int size = paramSizes.ParameterCount; result.put(paramSizes.Name, array.subArray(start, start + size)); start += size; } return(result); }
internal virtual void createDictionary() { for (int i = 0;i < noOfSentences;i++) { double score = 0; for (int j = 0;j < noOfSentences;j++) { score += intersectionMatrix[i][j]; } dictionary.put(sentences.get(i), score); ((Sentence)sentences.get(i)).score = score; } }
public virtual Builder ParameterizedWith(string name, TypeReference.Bound bound) { if (TypeParametersConflict == null) { TypeParametersConflict = new LinkedHashMap <string, TypeReference.Bound>(); } else if (TypeParametersConflict.containsKey(name)) { throw new System.ArgumentException(name + " defined twice"); } TypeParametersConflict.put(name, bound); return(this); }
public override Iterator <Map.Entry <IteratorIndex, SimpleView> > getIterator() { LinkedHashMap <IteratorIndex, SimpleView> map = new LinkedHashMap <IteratorIndex, SimpleView>(); for (int i = 0; i < _attrList.size(); i++) { SimpleView view = _attrList.get(i); map.put(IteratorIndex.create(view.getNodeName()), view); } return(map.entrySet().iterator()); }
//JAVA TO C# CONVERTER WARNING: Method 'throws' clauses are not available in .NET: //ORIGINAL LINE: private void calculateIndices(org.maltparser.core.syntaxgraph.PhraseStructure phraseStructure) throws org.maltparser.core.exception.MaltChainedException private void calculateIndices(PhraseStructure phraseStructure) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.SortedMap<int,int> heights = new java.util.TreeMap<int,int>(); SortedDictionary <int, int> heights = new SortedDictionary <int, int>(); foreach (int index in phraseStructure.NonTerminalIndices) { heights[index] = ((NonTerminalNode)phraseStructure.getNonTerminalNode(index)).Height; } bool done = false; int h = 1; int ntid = START_ID_OF_NONTERMINALS; nonTerminalIndexMap.clear(); while (!done) { done = true; foreach (int index in phraseStructure.NonTerminalIndices) { if (heights[index] == h) { NonTerminalNode nt = (NonTerminalNode)phraseStructure.getNonTerminalNode(index); nonTerminalIndexMap.put(nt.Index, ntid++); // nonTerminalIndexMap.put(nt.getIndex(), nt.getIndex()+START_ID_OF_NONTERMINALS-1); done = false; } } h++; } // boolean done = false; // int h = 1; //// int ntid = START_ID_OF_NONTERMINALS; //// nonTerminalIndexMap.clear(); // while (!done) { // done = true; // for (int index : phraseStructure.getNonTerminalIndices()) { // if (heights.get(index) == h) { // NonTerminalNode nt = (NonTerminalNode)phraseStructure.getNonTerminalNode(index); //// nonTerminalIndexMap.put(nt.getIndex(), ntid++); // nonTerminalIndexMap.put(nt.getIndex(), nt.getIndex()+START_ID_OF_NONTERMINALS-1); // done = false; // } // } // h++; // } }
/// <summary> /// Reloads the internal SPI list from the given <seealso cref="ClassLoader"/>. /// Changes to the service list are visible after the method ends, all /// iterators (e.g., from <seealso cref="#availableServices()"/>,...) stay consistent. /// /// <para><b>NOTE:</b> Only new service providers are added, existing ones are /// never removed or replaced. /// /// </para> /// <para><em>This method is expensive and should only be called for discovery /// of new service providers on the given classpath/classloader!</em> /// </para> /// </summary> public void reload(ClassLoader classloader) { lock (this) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final java.util.LinkedHashMap<String,Class> services = new java.util.LinkedHashMap<>(this.services); LinkedHashMap <string, Type> services = new LinkedHashMap <string, Type>(this.services); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final org.apache.lucene.util.SPIClassIterator<S> loader = org.apache.lucene.util.SPIClassIterator.get(clazz, classloader); SPIClassIterator <S> loader = SPIClassIterator.get(clazz, classloader); while (loader.hasNext()) { //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final Class service = loader.next(); Type service = loader.next(); //JAVA TO C# CONVERTER WARNING: The original Java variable was marked 'final': //ORIGINAL LINE: final String clazzName = service.getSimpleName(); string clazzName = service.SimpleName; string name = null; foreach (string suffix in suffixes) { if (clazzName.EndsWith(suffix, StringComparison.Ordinal)) { name = clazzName.Substring(0, clazzName.Length - suffix.Length).ToLower(Locale.ROOT); break; } } if (name == null) { throw new ServiceConfigurationError("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 // // TODO: 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.put(name, service); } } this.services = Collections.unmodifiableMap(services); } }
public virtual void addTexture(IRenderingEngine re, Texture texture) { int? key = getKey(texture.Addr, texture.ClutAddr, texture.ClutStart, texture.ClutMode); Texture previousTexture = cache.get(key); if (previousTexture != null) { previousTexture.deleteTexture(re); //JAVA TO C# CONVERTER TODO TASK: There is no .NET LinkedList equivalent to the Java 'remove' method: vramTextures.remove(previousTexture); } else { // Check if the cache is not growing too large if (cache.size() >= cacheMaxSize) { // Remove the LRU cache entry IEnumerator <KeyValuePair <int, Texture> > it = cache.entrySet().GetEnumerator(); //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: if (it.hasNext()) { //JAVA TO C# CONVERTER TODO TASK: Java iterators are only converted within the context of 'while' and 'for' loops: KeyValuePair <int, Texture> entry = it.next(); Texture lruTexture = entry.Value; lruTexture.deleteTexture(re); //JAVA TO C# CONVERTER TODO TASK: There is no .NET LinkedList equivalent to the Java 'remove' method: vramTextures.remove(lruTexture); //JAVA TO C# CONVERTER TODO TASK: .NET enumerators are read-only: it.remove(); statistics.entriesRemoved++; } } } cache.put(key, texture); if (isVramTexture(texture)) { vramTextures.AddLast(texture); } if (cache.size() > statistics.maxSizeUsed) { statistics.maxSizeUsed = cache.size(); } }
private static ICollection <Path> HitsToPaths(ICollection <Hit> depthHits, Node start, Node end, bool stopAsap, int maxResultCount) { LinkedHashMap <string, Path> paths = new LinkedHashMap <string, Path>(); foreach (Hit hit in depthHits) { foreach (Path path in HitToPaths(hit, start, end, stopAsap)) { paths.put(path.ToString(), path); if (paths.size() >= maxResultCount) { break; } } } return(paths.values()); }
// END-Factor // /** * Iterate over all the possible value assignments for the Random Variables * comprising this ProbabilityTable. * * @param pti * the ProbabilityTable Iterator to iterate. */ public void iterateOverTable(Factor.Iterator pti) { Map <RandomVariable, Object> possibleWorld = new LinkedHashMap <RandomVariable, Object>(); MixedRadixNumber mrn = new MixedRadixNumber(0, radices); do { foreach (RVInfo rvInfo in randomVarInfo.Values) { possibleWorld.put(rvInfo.getVariable(), rvInfo .getDomainValueAt(mrn.getCurrentNumeralValue(rvInfo . getRadixIdx ()))); } pti.iterate(possibleWorld, values[mrn.intValue()]); } while (mrn.increment()); }
// END-Factor // /** * Iterate over all the possible value assignments for the Random Variables * comprising this ProbabilityTable. * * @param pti * the ProbabilityTable Iterator to iterate. */ public void iterateOverTable(Factor.Iterator pti) { Map<RandomVariable, Object> possibleWorld = new LinkedHashMap<RandomVariable, Object>(); MixedRadixNumber mrn = new MixedRadixNumber(0, radices); do { foreach (RVInfo rvInfo in randomVarInfo.Values) { possibleWorld.put(rvInfo.getVariable(), rvInfo .getDomainValueAt(mrn.getCurrentNumeralValue(rvInfo . getRadixIdx ()))); } pti.iterate(possibleWorld, values[mrn.intValue()]); } while (mrn.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 ProbabilityTable divideBy(ProbabilityTable divisor) { if (!randomVarInfo.keySet().containsAll(divisor.randomVarInfo.keySet())) { throw new IllegalArgumentException( "Divisor must be a subset of the dividend."); } ProbabilityTable quotient = new ProbabilityTable(new List<RandomVariable>(randomVarInfo.Keys)); if (1 == divisor.getValues().Length) { double d = divisor.getValues()[0]; for (int i = 0; i < quotient.getValues().Length; i++) { if (0 == d) { quotient.getValues()[i] = 0; } else { quotient.getValues()[i] = getValues()[i]/d; } } } else { Set<RandomVariable> dividendDivisorDiff = SetOps .difference(new List<RVInfo>(randomVarInfo.keySet()), new List<RVInfo>(randomVarInfo.keySet())); Map<RandomVariable, RVInfo> tdiff = null; MixedRadixNumber tdMRN = null; if (dividendDivisorDiff.size() > 0) { tdiff = new LinkedHashMap<RandomVariable, RVInfo>(); foreach (RandomVariable rv in dividendDivisorDiff) { tdiff.put(rv, new RVInfo(rv)); } tdMRN = new MixedRadixNumber(0, createRadixs(tdiff)); } Map<RandomVariable, RVInfo> diff = tdiff; MixedRadixNumber dMRN = tdMRN; int[] qRVs = new int[quotient.radices.Length]; MixedRadixNumber qMRN = new MixedRadixNumber(0, quotient.radices); //ProbabilityTable.Iterator divisorIterator = new ProbabilityTable.Iterator() { // public void iterate(Map<RandomVariable, Object> possibleWorld, // double probability) { // foreach (RandomVariable rv in possibleWorld.keySet()) { // RVInfo rvInfo = quotient.randomVarInfo.get(rv); // qRVs[rvInfo.getRadixIdx()] = rvInfo // .getIdxForDomain(possibleWorld.get(rv)); // } // if (null != diff) { // // Start from 0 off the diff // dMRN.setCurrentValueFor(new int[diff.size()]); // do { // for (RandomVariable rv : diff.keySet()) { // RVInfo drvInfo = diff.get(rv); // RVInfo qrvInfo = quotient.randomVarInfo.get(rv); // qRVs[qrvInfo.getRadixIdx()] = dMRN // .getCurrentNumeralValue(drvInfo // .getRadixIdx()); // } // updateQuotient(probability); // } while (dMRN.increment()); // } else { // updateQuotient(probability); // } // } // // // //private void updateQuotient(double probability) { // int offset = (int) qMRN.getCurrentValueFor(qRVs); // if (0 == probability) { // quotient.getValues()[offset] = 0; // } else { // quotient.getValues()[offset] += getValues()[offset] // / probability; // } //} ////// }; // divisor.iterateOverTable(divisorIterator); // TODO } return quotient; }
// 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(); }