WeightedSample.java

Go to the documentation of this file.

package edu.tum.cs.bayesnets.inference;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

import edu.ksu.cis.bnj.ver3.core.BeliefNode;
import edu.ksu.cis.bnj.ver3.core.Domain;
import edu.tum.cs.bayesnets.core.BeliefNetworkEx;
import edu.tum.cs.bayesnets.core.Discretized;

public class WeightedSample {
        BeliefNetworkEx bn;
        public int[] nodeDomainIndices;
        public int[] nodeIndices;
        public double weight;
        public int trials;
        public int operations;  

        public WeightedSample(BeliefNetworkEx bn, int[] nodeDomainIndices, double weight, int[] nodeIndices, int trials) {
                this.bn = bn;
                if (nodeIndices == null) {
                        int numNodes = nodeDomainIndices.length;
                        nodeIndices = new int[numNodes];
                        for (int i = 0; i < numNodes; i++) {
                                nodeIndices[i] = i;
                        }
                }
                this.nodeIndices = nodeIndices;
                this.nodeDomainIndices = nodeDomainIndices;
                assert nodeIndices.length == nodeDomainIndices.length;
                this.weight = weight;
                this.trials = trials;
        }
        
        public WeightedSample(BeliefNetworkEx bn) {
                this(bn, new int[bn.bn.getNodes().length], 1.0, null, 0);
        }
        
        public WeightedSample(BeliefNetworkEx bn, int[] domainIndices) {
                this(bn, domainIndices, 1.0, null, 0);
        }

        public WeightedSample subSample(int[] queryNodes) {
                //BeliefNetworkEx.logger.debug(Arrays.toString(nodeDomainIndices));
                int[] resultIndices = new int[queryNodes.length];
                for (int i = 0; i < queryNodes.length; i++) {
                        resultIndices[i] = nodeDomainIndices[queryNodes[i]];
                }
                return new WeightedSample(bn, resultIndices, weight, queryNodes, 1);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#hashCode()
         */
        @Override
        public int hashCode() {
                return Arrays.hashCode(nodeDomainIndices);
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#equals(java.lang.Object)
         */
        @Override
        public boolean equals(Object obj) {
                if (this == obj)
                        return true;
                if (!(obj instanceof WeightedSample))
                        return false;
                return Arrays.equals(nodeDomainIndices,
                                (((WeightedSample) obj).nodeDomainIndices));
        }

        public Map<String, String> getAssignmentMap() {
                Map<String, String> result = new HashMap<String, String>();

                BeliefNode[] nodes = bn.bn.getNodes();
                for (int i = 0; i < nodeIndices.length; i++) {
                        try {
                                result.put(nodes[nodeIndices[i]].getName(),
                                                nodes[nodeIndices[i]].getDomain().getName(
                                                                nodeDomainIndices[i]));
                        } catch (RuntimeException e) {
                                e.printStackTrace();
                                throw e;
                        }
                }

                return result;
        }

        public Map<String, String> getUndiscretizedAssignmentMap() {
                Map<String, String> result = new HashMap<String, String>();

                BeliefNode[] nodes = bn.bn.getNodes();
                for (int i = 0; i < nodeIndices.length; i++) {
                        try {
                                Domain nodeDomain = nodes[nodeIndices[i]].getDomain();
                                String value = nodeDomain.getName(nodeDomainIndices[i]);
                                if (nodeDomain instanceof Discretized) {
                                        value = String.valueOf(((Discretized) nodeDomain)
                                                        .getExampleValue(nodeDomainIndices[i]));
                                }
                                result.put(nodes[nodeIndices[i]].getName(), value);
                        } catch (RuntimeException e) {
                                e.printStackTrace();
                                throw e;
                        }
                }
                return result;
        }

        /*
         * (non-Javadoc)
         * 
         * @see java.lang.Object#toString()
         */
        @Override
        public String toString() {
                return "WeightedSample(" + getAssignmentMap() + ", " + weight + ")";
        }

        public String toShortString() {
                return "WeightedSample(" + Arrays.toString(nodeDomainIndices)
                                + ", " + weight + ")";
        }

        public boolean checkAssignment(String[][] queries) {
                int[] indices = bn.getNodeDomainIndicesFromStrings(queries);
                for (int nodeIndex : nodeIndices) {
                        if (indices[nodeIndex] >= 0
                                        && indices[nodeIndex] != nodeDomainIndices[nodeIndex])
                                return false;
                }
                return true;
        }
        
        public String getCPDLookupString(BeliefNode node) {
                BeliefNode[] domain_product = node.getCPF().getDomainProduct();
                StringBuffer cond = new StringBuffer();
                for(int i = 0; i < domain_product.length; i++) {
                        if(i > 0)
                                cond.append(", ");
                        cond.append(domain_product[i].getName()).append(" = ");
                        cond.append(domain_product[i].getDomain().getName(nodeDomainIndices[this.bn.getNodeIndex(domain_product[i])]));
                }
                return cond.toString();
        }
}

---

srldb
Author(s): Dominik Jain, Stefan Waldherr, Moritz Tenorth
autogenerated on Fri Jan 11 09:58:30 2013