← Back to branch summary

~ubuntu-branches/ubuntu/trusty/weka/trusty-proposed

« back to all changes in this revision

Viewing changes to weka/classifiers/bayes/net/ParentSet.java

  • Committer: Bazaar Package Importer
  • Author(s): Soeren Sonnenburg
  • Date: 2008-02-24 09:18:45 UTC
  • Revision ID: james.westby@ubuntu.com-20080224091845-1l8zy6fm6xipbzsr
Tags: upstream-3.5.7+tut1
Import upstream version 3.5.7+tut1

Show diffs side-by-side

added added

removed removed

Lines of Context:
weka/classifiers/bayes/net/ParentSet.java
 
1
/*
 
2
 * This program is free software; you can redistribute it and/or modify
 
3
 * it under the terms of the GNU General Public License as published by
 
4
 * the Free Software Foundation; either version 2 of the License, or
 
5
 * (at your option) any later version.
 
6
 * 
 
7
 * This program is distributed in the hope that it will be useful,
 
8
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
9
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 
10
 * GNU General Public License for more details.
 
11
 * 
 
12
 * You should have received a copy of the GNU General Public License
 
13
 * along with this program; if not, write to the Free Software
 
14
 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 
15
 */
 
16
 
 
17
/*
 
18
 * ParentSet.java
 
19
 * Copyright (C) 2001 University of Waikato, Hamilton, New Zealand
 
20
 * 
 
21
 */
 
22
package weka.classifiers.bayes.net;
 
23
 
 
24
import weka.core.Instances;
 
25
 
 
26
import java.io.Serializable;
 
27
 
 
28
/**
 
29
 * Helper class for Bayes Network classifiers. Provides datastructures to
 
30
 * represent a set of parents in a graph.
 
31
 * 
 
32
 * @author Remco Bouckaert (rrb@xm.co.nz)
 
33
 * @version $Revision: 1.7 $
 
34
 */
 
35
public class ParentSet 
 
36
  implements Serializable {
 
37
  
 
38
  /** for serialization */
 
39
  static final long serialVersionUID = 4155021284407181838L;
 
40
 
 
41
  /**
 
42
   * Holds indexes of parents
 
43
   */
 
44
  private int[] m_nParents;
 
45
 
 
46
  /**
 
47
   * returns index parent of parent specified by index
 
48
   * 
 
49
   * @param iParent Index of parent
 
50
   * @return index of parent
 
51
   */
 
52
  public int getParent(int iParent) {
 
53
    return m_nParents[iParent];
 
54
  } 
 
55
  public int [] getParents() {return m_nParents;}
 
56
 
 
57
  /**
 
58
   * sets index parent of parent specified by index
 
59
   * 
 
60
   * @param iParent Index of parent
 
61
   * @param nNode index of the node that becomes parent
 
62
   */
 
63
  public void SetParent(int iParent, int nNode) {
 
64
        m_nParents[iParent] = nNode;
 
65
  } // SetParent
 
66
 
 
67
 
 
68
  /**
 
69
   * Holds number of parents
 
70
   */
 
71
  private int m_nNrOfParents = 0;
 
72
 
 
73
  /**
 
74
   * returns number of parents
 
75
   * @return number of parents
 
76
   */
 
77
  public int getNrOfParents() {
 
78
    return m_nNrOfParents;
 
79
  } 
 
80
 
 
81
  /**
 
82
   * test if node is contained in parent set
 
83
   * @param iNode node to test for
 
84
   * @return number of parents
 
85
   */
 
86
        public boolean contains(int iNode) {
 
87
                for (int iParent = 0; iParent < m_nNrOfParents; iParent++) {
 
88
                        if (m_nParents[iParent] == iNode) {
 
89
                                return true;
 
90
                        }
 
91
                }
 
92
                return false;
 
93
        }
 
94
  /**
 
95
   * Holds cardinality  of parents (= number of instantiations the parents can take)
 
96
   */
 
97
  private int m_nCardinalityOfParents = 1;
 
98
 
 
99
  /**
 
100
   * returns cardinality of parents
 
101
   * 
 
102
   * @return the cardinality
 
103
   */
 
104
  public int getCardinalityOfParents() {
 
105
    return m_nCardinalityOfParents;
 
106
  } 
 
107
 
 
108
  /**
 
109
   * returns cardinality of parents after recalculation
 
110
   * 
 
111
   * @return the cardinality
 
112
   */
 
113
  public int getFreshCardinalityOfParents(Instances _Instances) {
 
114
          m_nCardinalityOfParents = 1;
 
115
          for (int iParent = 0; iParent < m_nNrOfParents; iParent++) {
 
116
                m_nCardinalityOfParents *= _Instances.attribute(m_nParents[iParent]).numValues();
 
117
          }
 
118
      return m_nCardinalityOfParents;
 
119
  }
 
120
  /**
 
121
   * default constructor
 
122
   */
 
123
  public ParentSet() {
 
124
    m_nParents = new int[10];
 
125
    m_nNrOfParents = 0;
 
126
    m_nCardinalityOfParents = 1;
 
127
  }    // ParentSet
 
128
 
 
129
  /**
 
130
   * constructor
 
131
   * @param nMaxNrOfParents upper bound on nr of parents
 
132
   */
 
133
  public ParentSet(int nMaxNrOfParents) {
 
134
    m_nParents = new int[nMaxNrOfParents];
 
135
    m_nNrOfParents = 0;
 
136
    m_nCardinalityOfParents = 1;
 
137
  }    // ParentSet
 
138
 
 
139
  /**
 
140
   * copy constructor
 
141
   * @param other other parent set
 
142
   */
 
143
  public ParentSet(ParentSet other) {
 
144
    m_nNrOfParents = other.m_nNrOfParents;
 
145
    m_nCardinalityOfParents = other.m_nCardinalityOfParents;
 
146
    m_nParents = new int[m_nNrOfParents];
 
147
 
 
148
    for (int iParent = 0; iParent < m_nNrOfParents; iParent++) {
 
149
      m_nParents[iParent] = other.m_nParents[iParent];
 
150
    } 
 
151
  }    // ParentSet
 
152
 
 
153
  /**
 
154
   * reserve memory for parent set
 
155
   * 
 
156
   * @param nSize maximum size of parent set to reserver memory for
 
157
   */
 
158
  public void maxParentSetSize(int nSize) {
 
159
    m_nParents = new int[nSize];
 
160
  }    // MaxParentSetSize
 
161
 
 
162
  /**
 
163
   * Add parent to parent set and update internals (specifically the cardinality of the parent set)
 
164
   * 
 
165
   * @param nParent parent to add
 
166
   * @param _Instances used for updating the internals
 
167
   */
 
168
  public void addParent(int nParent, Instances _Instances) {
 
169
   if (m_nNrOfParents == 10) {
 
170
        // reserve more memory
 
171
        int [] nParents = new int[50];
 
172
        for (int i = 0; i < m_nNrOfParents; i++) {
 
173
            nParents[i] = m_nParents[i];
 
174
        }
 
175
        m_nParents = nParents;
 
176
   }
 
177
    m_nParents[m_nNrOfParents] = nParent;
 
178
    m_nNrOfParents++;
 
179
    m_nCardinalityOfParents *= _Instances.attribute(nParent).numValues();
 
180
  }    // AddParent
 
181
 
 
182
  /**
 
183
   * Add parent to parent set at specific location 
 
184
   * and update internals (specifically the cardinality of the parent set)
 
185
   * 
 
186
   * @param nParent parent to add
 
187
   * @param iParent location to add parent in parent set
 
188
   * @param _Instances used for updating the internals
 
189
   */
 
190
  public void addParent(int nParent, int iParent, Instances _Instances) {
 
191
   if (m_nNrOfParents == 10) {
 
192
        // reserve more memory
 
193
        int [] nParents = new int[50];
 
194
                for (int i = 0; i < m_nNrOfParents; i++) {
 
195
                        nParents[i] = m_nParents[i];
 
196
                }
 
197
                m_nParents = nParents;
 
198
   }
 
199
        for (int iParent2 = m_nNrOfParents; iParent2 > iParent; iParent2--) {
 
200
                m_nParents[iParent2] = m_nParents[iParent2 - 1];                
 
201
        }
 
202
        m_nParents[iParent] = nParent;
 
203
        m_nNrOfParents++;
 
204
        m_nCardinalityOfParents *= _Instances.attribute(nParent).numValues();
 
205
  } // AddParent
 
206
 
 
207
  /** delete node from parent set
 
208
   * @param nParent node number of the parent to delete
 
209
   * @param _Instances data set
 
210
   * @return location of the parent in the parent set. This information can be 
 
211
   * used to restore the parent set using the addParent method.
 
212
   */
 
213
  public int deleteParent(int nParent, Instances _Instances) {
 
214
      int iParent = 0;
 
215
      while ((m_nParents[iParent] != nParent) && (iParent < m_nNrOfParents)) {
 
216
          iParent++;
 
217
      }
 
218
      int iParent2 = -1;
 
219
      if (iParent < m_nNrOfParents) {
 
220
        iParent2 = iParent;
 
221
      }
 
222
      if (iParent < m_nNrOfParents) {
 
223
        while (iParent < m_nNrOfParents - 1) {
 
224
            m_nParents[iParent] = m_nParents[iParent + 1];
 
225
            iParent++;
 
226
        }
 
227
        m_nNrOfParents--;
 
228
        m_nCardinalityOfParents /= _Instances.attribute(nParent).numValues();
 
229
      }
 
230
      return iParent2;
 
231
  } // DeleteParent
 
232
  
 
233
  /**
 
234
   * Delete last added parent from parent set and update internals (specifically the cardinality of the parent set)
 
235
   * 
 
236
   * @param _Instances used for updating the internals
 
237
   */
 
238
  public void deleteLastParent(Instances _Instances) {
 
239
    m_nNrOfParents--;
 
240
    m_nCardinalityOfParents = 
 
241
      m_nCardinalityOfParents 
 
242
      / _Instances.attribute(m_nParents[m_nNrOfParents]).numValues();
 
243
  }    // DeleteLastParent
 
244
 
 
245
        /** Copy makes current parents set equal to other parent set
 
246
         * 
 
247
         * @param other : parent set to make a copy from
 
248
         */
 
249
        public void copy(ParentSet other) {
 
250
                m_nCardinalityOfParents = other.m_nCardinalityOfParents;
 
251
                m_nNrOfParents = other.m_nNrOfParents;
 
252
                for (int iParent = 0; iParent < m_nNrOfParents; iParent++) {
 
253
                        m_nParents[iParent] = other.m_nParents[iParent];
 
254
                }
 
255
        } // Copy
 
256
 
 
257
}      // class ParentSet
 
258
 
 
259
 
 
260
 
 
261