예제 #1
0
 /**
  * Verifies the support and creates the infrastructure to generate initial projectedDBs for each
  * element which respects the temporal constraint.
  *
  * @param s The db sequence to verify.
  * @param alphabet The set of elements in the db.
  * @param sup An array to store elements support.
  * @param projDBs
  * @param sPos The sequence id.
  * @param eInd The event position in the sequence.
  * @param inParallel A flag to state if we are verifying at the same instant or in the next ones
  */
 @Override
 public void verifyAcceptance(
     EventSequence alpha,
     EventSequence s,
     Vector<Element> alphabet,
     int[] sup,
     ProjectedDB[] projDBs,
     int indProj,
     int sPos,
     int eInd,
     boolean inParallel,
     BitSet visited,
     BitSet accepted) {
   // While gap is verified
   int from = eInd + 1;
   while (from < s.length() && (from - eInd <= m_maxDist)) {
     verifyContentAcceptance(
         alpha,
         s.elementAtIndex(from).getSet(),
         alphabet,
         sup,
         projDBs,
         indProj,
         sPos,
         from,
         inParallel,
         visited,
         accepted);
     from++;
   }
 }
예제 #2
0
 /**
  * @param db
  * @return a db transformed in a database of events ???
  */
 public Database preProcessing(Database db) {
   Vector<Element> alphabet = m_tdm.m_contentC.m_taxonomy.getAlphabet(m_tdm.m_contentC.m_level);
   Database preprocDB = new Database();
   for (int i = 0; i < db.getSize(); i++) {
     EventSequence s = db.elementAt(i);
     Vector<Event> events = new Vector<Event>(0);
     for (int k = 0; k < s.length(); k++) {
       Event e = s.elementAtIndex(k);
       if (m_tdm.m_temporalC.accepts(e)) {
         Vector<Element> v = getParents(e.getSet(), alphabet, m_tdm.m_contentC.m_taxonomy);
         if (null != v) events.addElement(new Event(new ItemSet(v), e.getInstant()));
       }
     }
     if (0 != events.size()) preprocDB.addElement(new EventSequence(events));
   }
   preprocDB.setAlphabet(alphabet);
   return preprocDB;
 }
예제 #3
0
 /**
  * Verifies the support and creates the infrastructure to generate initial projectedDBs for each
  * element in the database.
  *
  * @param s The db sequence to verify.
  * @param alphabet The set of elements in the db.
  * @param sup An array to store elements support.
  * @param seqDB An array of vectores with the ids of sequences where each element occur.
  * @param posDB An array of vectores with the positions where each element occur.
  * @param index The first index to look for.
  * @return True if the sequence supports some valid elements.
  */
 public boolean verifyGeneralAcceptance(
     EventSequence s,
     Vector<Element> alphabet,
     long[] sup,
     Vector<Integer>[] seqDB,
     Vector<Integer>[] posDB,
     int index) {
   boolean seqSupports = false;
   BitSet bs = new BitSet(alphabet.size());
   bs.clear();
   int from = 0;
   while (from < s.length()) {
     seqSupports = true;
     verifyContentGeneralAcceptance(
         s.elementAtIndex(from), alphabet, bs, sup, seqDB, posDB, index, from);
     from++;
   }
   return seqSupports;
 }
예제 #4
0
 /**
  * Returns true if the el can be appended to s, in accordance to this relaxation. ******** It is
  * needed to redefine this method, for some subclasses. *******
  *
  * @param s The sequence already accepted.
  * @param el The element to append
  * @param inParallel A flag to state if we are verifying at the same instant or in the next ones
  */
 @Override
 protected boolean isAcceptedByRelaxation(EventSequence s, Element el, boolean inParallel) {
   ItemSet sk = s.elementAtIndex(s.length() - 1).getSet();
   Element last = sk.elementAt(sk.size() - 1);
   return (!inParallel || el.isGreaterThan(last));
 }