C# Set.remove方法代码示例

        // END-BayesianNetwork
        //

        //
        // PRIVATE METHODS
        //
        private void checkIsDAGAndCollectVariablesInTopologicalOrder()
        {

            // Topological sort based on logic described at:
            // http://en.wikipedia.org/wiki/Topoligical_sorting
            Set<Node> seenAlready = new Set<Node>();
            Map<Node, List<Node>> incomingEdges = new Map<Node, List<Node>>();
            Set<Node> s = new Set<Node>();
            foreach (Node n in this.rootNodes)
            {
                walkNode(n, seenAlready, incomingEdges, s);
            }
            while (!(s.Count == 0))
            {
                HashSet<Node>.Enumerator enumerator = s.GetEnumerator();
                enumerator.MoveNext();
                Node n = enumerator.Current;
                s.remove(n);
                variables.Add(n.getRandomVariable());
                varToNodeMap.put(n.getRandomVariable(), n);
                foreach (Node m in n.getChildren())
                {
                    List<Node> edges = incomingEdges.get(m);
                    edges.Remove(n);
                    if (edges.Count == 0)
                    {
                        s.add(m);
                    }
                }
            }

            foreach (List<Node> edges in incomingEdges.values())
            {
                if (!(edges.Count == 0))
                {
                    throw new IllegalArgumentException(
                        "Network contains at least one cycle in it, must be a DAG.");
                }
            }
        }

        // END-BayesInference
        //

        //
        // PROTECTED METHODS
        //
        /**
         * <b>Note:</b>Override this method for a more efficient implementation as
         * outlined in AIMA3e pgs. 527-28. Calculate the hidden variables from the
         * Bayesian Network. The default implementation does not perform any of
         * these.<br>
         * <br>
         * Two calcuations to be performed here in order to optimize iteration over
         * the Bayesian Network:<br>
         * 1. Calculate the hidden variables to be enumerated over. An optimization
         * (AIMA3e pg. 528) is to remove 'every variable that is not an ancestor of
         * a query variable or evidence variable as it is irrelevant to the query'
         * (i.e. sums to 1). 2. The subset of variables from the Bayesian Network to
         * be retained after irrelevant hidden variables have been removed.
         * 
         * @param X
         *            the query variables.
         * @param e
         *            observed values for variables E.
         * @param bn
         *            a Bayes net with variables {X} &cup; E &cup; Y /* Y = hidden
         *            variables //
         * @param hidden
         *            to be populated with the relevant hidden variables Y.
         * @param bnVARS
         *            to be populated with the subset of the random variables
         *            comprising the Bayesian Network with any irrelevant hidden
         *            variables removed.
         */

        protected void calculateVariables(RandomVariable[] X,
                                          AssignmentProposition[] e, BayesianNetwork bn,
                                          Set<RandomVariable> hidden, List<RandomVariable> bnVARS)
        {

            bnVARS.AddRange(bn.getVariablesInTopologicalOrder());
            hidden.addAll(bnVARS);

            foreach (RandomVariable x in X)
            {
                hidden.remove(x);
            }
            foreach (AssignmentProposition ap in e)
            {
                hidden.removeAll(ap.getScope());
            }

            return;
        }

        public ProbabilityTable sumOut(params RandomVariable[] vars)
        {
            Set<RandomVariable> soutVars = new Set<RandomVariable>(
                this.randomVarInfo.keySet());
            foreach (RandomVariable rv in vars)
            {
                soutVars.remove(rv);
            }
            ProbabilityTable summedOut = new ProbabilityTable(soutVars);
            if (1 == summedOut.getValues().Length)
            {
                summedOut.getValues()[0] = getSum();
            }
            else
            {
                // Otherwise need to iterate through this distribution
                // to calculate the summed out distribution.
                Object[] termValues = new Object[summedOut.randomVarInfo
                    .size()];
                //ProbabilityTable.Iterator di = new ProbabilityTable.Iterator() {
                //    public void iterate(Map<RandomVariable, Object> possibleWorld,
                //            double probability) {

                //        int i = 0;
                //        foreach (RandomVariable rv in summedOut.randomVarInfo.keySet()) {
                //            termValues[i] = possibleWorld.get(rv);
                //            i++;
                //        }
                //        summedOut.getValues()[summedOut.getIndex(termValues)] += probability;
                //    }
                //};
                //iterateOverTable(di);
                //TODO:
            }

            return summedOut;
        }