Пример #1
0
        //Sets the inervals
        private void setIntervalsAndRelations()
        {
            relations = new Dictionary <int, Dictionary <int, string> >();
            TemporalDB db = CCMiner.mainDB;

            sequences = new List <EventSequence>();
            for (int k = 0; k < actual_ids.Count; k++)
            {
                string t_id = TransformedDB.getID(actual_ids[k]);
                ids.Add(k, t_id);
                string        id       = t_id;
                EventSequence seq      = new EventSequence();
                List <string> seq_syms = CoincidenceManager.
                                         getPatternSymbols(pDB.patterns[actual_ids[k]].Item1);
                foreach (string sym in seq_syms)
                {
                    seq.ints.Add(db.seqs[id].getInterval(sym));
                }
                sequences.Add(seq);
                if (k == 0)
                {
                    for (int i = 0; i < length; i++)
                    {
                        relations.Add(i, new Dictionary <int, string>());
                        for (int j = i + 1; j < length; j++)
                        {
                            EventInterval ei1 = seq.ints[i];
                            EventInterval ei2 = seq.ints[j];
                            string        rel = getRelation(ei1, ei2);
                            relations[i].Add(j, rel);
                        }
                    }
                }
            }
        }
Пример #2
0
        //Returns the slices that appear before slice in the given coincidence
        //Also the slices that appear in the previous co, if exists and partial are added
        private List <string> getSlicesBeforeInCo(string slc, List <string> coes, int index, string pat, string id, int last_time)
        {
            List <string> befSlices   = new List <string>();
            List <string> prev_slices = new List <string>();

            if (index > 0 && CoincidenceManager.isPartialCo(coes[index - 1]))
            {
                prev_slices = CoincidenceManager.getSymPartOfSlices(CoincidenceManager.splitCoToSlices(coes[index - 1]));
            }
            List <string> cur_coes = new List <string>();

            for (int i = 0; i < index + 1; i++)
            {
                cur_coes.Add(coes[i]);
            }
            cur_coes[index] = "";
            fillSliceList(befSlices, prev_slices, cur_coes, pat, id, last_time);
            if (slc[0] == Constants.MEET_REP)
            {
                return(befSlices);
            }
            //Added slices that appears in the previous coincidence after the previous slice if exist
            string cur_slc = slc;

            if (slc[0] == Constants.MEET_REP)
            {
                cur_slc = cur_slc.Substring(1);
            }
            cur_coes[index] = CoincidenceManager.getPartBefore(coes[index], cur_slc);
            List <string> allSlices = CoincidenceManager.splitCoToSlices(cur_coes[index]);

            //List<string> allSlices = CoincidenceManager.getSymPartOfSlices(CoincidenceManager.splitCoToSlices(cur_coes[index]));
            fillSliceList(befSlices, allSlices, cur_coes, pat, id, last_time);
            return(befSlices);
        }
Пример #3
0
 //Checks if next co meet slice can be preserved, if exists
 private static bool checkNextCoMeetOption(List <string> co, string pat)
 {
     if (lastPatSlice(pat).IndexOf('-') >= 0 && co.Count > 0)
     {
         return(CoincidenceManager.isPartialCo(co[0]));
     }
     return(false);
 }
Пример #4
0
        //Returns the frequent slices with their current supports
        //Returns also the infriquent slices as a list if the flag is set to true
        public Dictionary <string, int> slicesFreq()
        {
            //vertical support in current db entities (extended)
            Dictionary <string, int> slices_support = new Dictionary <string, int>();
            //Entries IDs and the slices already seen for it
            Dictionary <string, List <string> > slices_line_ignore = new Dictionary <string, List <string> >();

            //For each entity postfix in the current db:
            foreach (KeyValuePair <string, List <string> > entry in trans_db)
            {
                //Add the entity id to ignores if its the first time we see it
                string ent_id = getID(entry.Key);
                if (!slices_line_ignore.ContainsKey(entry.Key))
                {
                    slices_line_ignore.Add(entry.Key, new List <string>());
                }
                int time = patterns[entry.Key].Item2;
                //Take the slices of the postfix
                List <string> concrete_slices = CoincidenceManager.splitCoSeqToSlices(entry.Value,
                                                                                      (slc) => maxGapHolds(ent_id, time, slc));
                //For each concrete slice:
                for (int i = 0; i < concrete_slices.Count; i++)
                {
                    //if slice is @x: Do the following both for @x and x
                    //otherwise: Do only for x
                    string slc      = CoincidenceManager.getSymPartOfSlice(concrete_slices[i]);
                    string conc_slc = concrete_slices[i];
                    for (int j = 0; j < 2; j++)
                    {
                        if (slices_support.ContainsKey(slc))
                        {
                            //Not the first time we meet the slice
                            if (!slices_line_ignore[entry.Key].Contains(slc))
                            {
                                slices_support[slc]++;
                                slices_line_ignore[entry.Key].Add(slc);
                            }
                        }
                        else
                        {
                            //First time we see the slice
                            slices_support.Add(slc, 1);
                            slices_line_ignore[entry.Key].Add(slc);
                        }
                        if (slc[0] == Constants.MEET_REP)
                        {
                            slc      = slc.Substring(1);
                            conc_slc = conc_slc.Substring(1);
                        }
                        else
                        {
                            break;
                        }
                    }
                }
            }
            return(slices_support);
        }
Пример #5
0
 //Adds a pattern to the patterns collection
 public void addPattern(string pat, int sup, TransformedDB projDB)
 {
     using (FileStream fileStream = new FileStream(Constants.OUT_FILE, FileMode.Append, FileAccess.Write))
     {
         TextWriter      tw = new StreamWriter(fileStream);
         TemporalPattern tp = new TemporalPattern(CoincidenceManager.outToCoSeq(pat), sup, projDB);
         tw.WriteLine(tp.ToString());
         tw.Close();
     }
 }
Пример #6
0
        //
        private static KeyValuePair <string, string> getRestCo(string slice, int co_index, List <string> fullCoes,
                                                               string pattern, string id, string prev_oc, int time)
        {
            string slc = slice.Substring(0, slice.Length - 1);

            if (slice[0] == Constants.MEET_REP)
            {
                slc = slc.Substring(1);
            }
            if (slice[0] == Constants.CO_REP)
            {
                slc = slc.Substring(1);
            }
            if (fullCoes[co_index].IndexOf(slc) < 0)
            {
                return(new KeyValuePair <string, string>(null, null));
            }
            //co_slices includes only one slice
            string        rest           = "";
            int           j              = 0;
            List <string> fullCo_slices  = null;
            string        app            = "";
            string        last_pat_slice = lastPatSlice(pattern);
            bool          passed_prev    = prev_oc.Equals("");

            if (fullCoes[co_index].Length > 0 && fullCoes[co_index][0] == Constants.MEET_REP)
            //coincidence has @ inside of it
            {
                if (co_index == 0 || (co_index == 1 && CoincidenceManager.isPartialCo(fullCoes[0])))
                {
                    if (last_pat_slice.IndexOf(Constants.FIN_REP) >= 0)
                    {
                        //slice is pos: has to be @x+ (don't keep the @)
                        if (slice.IndexOf(Constants.ST_REP) >= 0 && slice.IndexOf(Constants.MEET_REP) >= 0)
                        {
                            //slice = @x+
                            fullCo_slices = CoincidenceManager.splitCoToSlices(fullCoes[co_index]);
                            for (int i = 0; i < fullCo_slices.Count; i++)
                            {
                                if (slice.Equals(fullCo_slices[i].Substring(0, fullCo_slices[i]
                                                                            .IndexOf(Constants.DUP_SYM)) + fullCo_slices[i][fullCo_slices[i].Length - 1]) &&
                                    maxGapHolds(id, time, fullCo_slices[i]))
                                {
                                    app = fullCo_slices[i];
                                    if (app.Equals(prev_oc))
                                    {
                                        passed_prev = true;
                                        continue;
                                    }
                                    if (!passed_prev)
                                    {
                                        continue;
                                    }
                                    j++;
                                    if (i < fullCo_slices.Count - 1)
                                    {
                                        for (int k = i + 1; k < fullCo_slices.Count; k++)
                                        {
                                            if (fullCo_slices[k][0] == Constants.MEET_REP)
                                            {
                                                string add = "";
                                                if (fullCo_slices[k].Substring(1)[0] != Constants.CO_REP)
                                                {
                                                    add += Constants.CO_REP;
                                                }
                                                rest += add + fullCo_slices[k].Substring(1);
                                            }
                                            else
                                            {
                                                string add = "";
                                                if (fullCo_slices[k][0] != Constants.CO_REP)
                                                {
                                                    add += Constants.CO_REP;
                                                }
                                                rest += add + fullCo_slices[k];
                                            }
                                        }
                                    }
                                    break;
                                }
                            }
                            if (j == 1)
                            {
                                return(new KeyValuePair <string, string>(rest, app));
                            }
                        }
                        return(new KeyValuePair <string, string>(null, null));
                    }
                    return(new KeyValuePair <string, string>(null, null));
                }
                //has to be without @
                if (slice.IndexOf(Constants.MEET_REP) < 0)
                {
                    fullCo_slices = CoincidenceManager.splitCoToSlices(fullCoes[co_index]);
                    for (int i = 0; i < fullCo_slices.Count; i++)
                    {
                        if ((slice.Equals(fullCo_slices[i].Substring(0, fullCo_slices[i]
                                                                     .IndexOf(Constants.DUP_SYM)) + fullCo_slices[i][fullCo_slices[i].Length - 1]) ||
                             (fullCo_slices[i][0] == Constants.MEET_REP &&
                              slice.Equals(fullCo_slices[i].Substring(1, fullCo_slices[i]
                                                                      .IndexOf(Constants.DUP_SYM) - 1) + fullCo_slices[i][fullCo_slices[i].Length - 1]))) &&
                            maxGapHolds(id, time, fullCo_slices[i]))
                        {
                            app = fullCo_slices[i];
                            if (app[0] == Constants.MEET_REP)
                            {
                                app = app.Substring(1);
                            }
                            if (app.Equals(prev_oc))
                            {
                                passed_prev = true;
                                continue;
                            }
                            if (!passed_prev)
                            {
                                continue;
                            }
                            if (app.IndexOf(Constants.FIN_REP) >= 0 &&
                                !CoincidenceManager.checkNoEndBeforeStart(app, pattern))
                            {
                                continue;
                            }
                            j++;
                            if (i < fullCo_slices.Count - 1)
                            {
                                for (int k = i + 1; k < fullCo_slices.Count; k++)
                                {
                                    if (fullCo_slices[k][0] == Constants.MEET_REP)
                                    {
                                        string add = "";
                                        if (fullCo_slices[k].Substring(1)[0] != Constants.CO_REP)
                                        {
                                            add += Constants.CO_REP;
                                        }
                                        rest += add + fullCo_slices[k].Substring(1);
                                    }
                                    else
                                    {
                                        string add = "";
                                        if (fullCo_slices[k][0] != Constants.CO_REP)
                                        {
                                            add += Constants.CO_REP;
                                        }
                                        rest += add + fullCo_slices[k];
                                    }
                                }
                            }
                            break;
                        }
                    }
                    if (j == 1)
                    {
                        return(new KeyValuePair <string, string>(rest, app));
                    }
                }
                return(new KeyValuePair <string, string>(null, null));
            }
            //coincidence has no @ in it
            fullCo_slices = CoincidenceManager.splitCoToSlices(fullCoes[co_index]);
            for (int i = 0; i < fullCo_slices.Count; i++)
            {
                if (slice.Equals(fullCo_slices[i].Substring(0, fullCo_slices[i]
                                                            .IndexOf(Constants.DUP_SYM)) + fullCo_slices[i][fullCo_slices[i].Length - 1]) &&
                    maxGapHolds(id, time, fullCo_slices[i]))
                {
                    app = fullCo_slices[i];
                    if (app.Equals(prev_oc))
                    {
                        passed_prev = true;
                        continue;
                    }
                    if (!passed_prev)
                    {
                        continue;
                    }
                    if (app.IndexOf(Constants.FIN_REP) >= 0 &&
                        !CoincidenceManager.checkNoEndBeforeStart(app, pattern))
                    {
                        continue;
                    }
                    j++;
                    if (i < fullCo_slices.Count - 1)
                    {
                        for (int k = i + 1; k < fullCo_slices.Count; k++)
                        {
                            string add = "";
                            if (fullCo_slices[k][0] != Constants.CO_REP)
                            {
                                add += Constants.CO_REP;
                            }
                            rest += add + fullCo_slices[k];
                        }
                    }
                    break;
                }
            }
            if (j == 1)
            {
                return(new KeyValuePair <string, string>(rest, app));
            }
            return(new KeyValuePair <string, string>(null, null));
        }
Пример #7
0
        //Returns the slices that appears in the i-th co-occuring-checking period in the DB for the last slice
        private List <string> ithCo(string slice)
        {
            string slicetmp = slice[0] == Constants.CO_REP || slice[0] == Constants.MEET_REP ?
                              slice.Substring(1) : slice;
            Dictionary <string, int> ith_co = new Dictionary <string, int>();
            int app_counter = 0;

            foreach (KeyValuePair <string, List <string> > entry in trans_db)
            {
                List <string> seq_coes  = entry.Value; //Split entry to coincidences
                int           last_time = patterns[entry.Key].Item2;
                KeyValuePair <int, KeyValuePair <List <string>, string> > proj =
                    canProjectBy(slice, seq_coes, patterns[entry.Key].Item1, getID(entry.Key), 0, "", last_time);
                int           cpb = proj.Key;
                List <string> suspect;
                while (cpb >= 0)
                {
                    app_counter++;
                    string pref = "";
                    suspect = new List <string>();
                    if (CoincidenceManager.isPartialCo(seq_coes[cpb]))
                    {
                        pref = Constants.CO_REP + "";
                    }
                    else if (seq_coes[cpb].IndexOf(Constants.MEET_REP) >= 0 && (cpb == 0 ||
                                                                                (cpb == 1 && CoincidenceManager.isPartialCo(seq_coes[cpb - 1]))))
                    {
                        pref = Constants.MEET_REP + "";
                    }
                    List <string> toAdd = CoincidenceManager.getSymPartOfSlices
                                              (CoincidenceManager.splitCoToSlices(seq_coes[cpb]));
                    foreach (string s in toAdd)
                    {
                        string stmp = s[0] == Constants.CO_REP || s[0] == Constants.MEET_REP ?
                                      s.Substring(1) : s;
                        if (stmp.Equals(slicetmp))
                        {
                            break;
                        }
                        if (!suspect.Contains(pref + stmp))
                        {
                            suspect.Add(pref + stmp);
                        }
                    }
                    //suspect = getSlicesBeforeInCo(slice, seq_coes, cpb, patterns[entry.Key].Item1, getID(entry.Key), last_time);
                    //Add occurences of the slices that appeared in the current occurence of 'slice'
                    foreach (string sus in suspect)
                    {
                        if (ith_co.ContainsKey(sus))
                        {
                            ith_co[sus]++;
                        }
                        else
                        {
                            ith_co.Add(sus, 1);
                        }
                    }
                    proj = canProjectBy(slice, seq_coes, patterns[entry.Key].Item1, getID(entry.Key), proj.Key, proj.Value.Value, last_time);
                    cpb  = proj.Key;
                }
            }
            //Take those that always appear
            List <string> ic = new List <string>();

            foreach (KeyValuePair <string, int> entry in ith_co)
            {
                if (entry.Value == app_counter)
                {
                    string tmp = entry.Key[0] == Constants.MEET_REP || entry.Key[0] == Constants.CO_REP ?
                                 entry.Key.Substring(1) : entry.Key;
                    if (!ic.Contains(tmp))
                    {
                        ic.Add(tmp);
                    }
                }
            }
            return(ic);
        }
Пример #8
0
        //Returns the slices that appears in the i-th before-checking period in the DB for the last slice
        private List <string> ithBefore(string slice)
        {
            Dictionary <string, int> ith_bef      = new Dictionary <string, int>();
            Dictionary <string, int> meet_ith_bef = new Dictionary <string, int>();
            int app_counter = 0;

            foreach (KeyValuePair <string, List <string> > entry in trans_db)
            {
                List <string> seq_coes  = entry.Value; //Split entry to coincidences
                int           last_time = patterns[entry.Key].Item2;
                KeyValuePair <int, KeyValuePair <List <string>, string> > proj =
                    canProjectBy(slice, seq_coes, patterns[entry.Key].Item1, getID(entry.Key), 0, "", last_time); //Returns co index and postfix
                int cpb = proj.Key;
                //bool skip_one;
                List <string> suspect;
                List <string> meet_suspect;
                while (cpb >= 0)
                {
                    //skip_one = (seq_coes.Count > 0 && seq_coes[0].IndexOf(Constants.CO_REP) >= 0);
                    suspect      = new List <string>();
                    meet_suspect = new List <string>();
                    app_counter++;
                    List <string> cur_coes = new List <string>();
                    for (int i = 0; i < cpb; i++)
                    {
                        cur_coes.Add("");
                    }
                    string pref;
                    for (int i = 0; i < cpb; i++)
                    {
                        /*if (skip_one)
                         * {
                         *  skip_one = false;
                         *  continue;
                         * }*/
                        pref = "";
                        if (i == 0)
                        {
                            if (CoincidenceManager.isPartialCo(seq_coes[i]))
                            {
                                pref = Constants.CO_REP + "";
                            }
                            else if (seq_coes[i].IndexOf(Constants.MEET_REP) >= 0)
                            {
                                pref = Constants.MEET_REP + "";
                            }
                        }
                        else if (i == 1)
                        {
                            if (seq_coes[i].IndexOf(Constants.MEET_REP) >= 0 &&
                                CoincidenceManager.isPartialCo(seq_coes[i - 1]))
                            {
                                pref = Constants.MEET_REP + "";
                            }
                        }
                        bool b1 = i == cpb - 1 && seq_coes[cpb].IndexOf(Constants.MEET_REP) >= 0;
                        bool b2 = slice[0] == Constants.MEET_REP;
                        if (b1 != b2)
                        {
                            List <string> toAdd1 = CoincidenceManager.getSymPartOfSlices
                                                       (CoincidenceManager.splitCoToSlices(seq_coes[i]));
                            List <string> conc_toAdd1 = CoincidenceManager.splitCoToSlices(seq_coes[i]);
                            int           ind1        = 0;
                            foreach (string s in toAdd1)
                            {
                                string stmp = s[0] == Constants.CO_REP || s[0] == Constants.MEET_REP ?
                                              s.Substring(1) : s;
                                string cs    = conc_toAdd1[ind1];
                                string cstmp = cs[0] == Constants.CO_REP || cs[0] == Constants.MEET_REP ?
                                               cs.Substring(1) : cs;
                                if (!meet_suspect.Contains(pref + stmp) &&
                                    (stmp.IndexOf(Constants.FIN_REP) >= 0 ||
                                     (maxGapHolds(getID(entry.Key), last_time, cstmp) &&
                                      maxGapHolds(getID(entry.Key), getInt(getID(entry.Key), cstmp).
                                                  st_time, proj.Value.Value))))
                                {
                                    meet_suspect.Add(pref + stmp);
                                }
                                ind1++;
                            }
                            continue;
                        }
                        List <string> toAdd = CoincidenceManager.getSymPartOfSlices
                                                  (CoincidenceManager.splitCoToSlices(seq_coes[i]));
                        List <string> conc_toAdd = CoincidenceManager.splitCoToSlices(seq_coes[i]);
                        int           ind        = 0;
                        foreach (string s in toAdd)
                        {
                            string stmp = s[0] == Constants.CO_REP || s[0] == Constants.MEET_REP ?
                                          s.Substring(1) : s;
                            string cs    = conc_toAdd[ind];
                            string cstmp = cs[0] == Constants.CO_REP || cs[0] == Constants.MEET_REP ?
                                           cs.Substring(1) : cs;
                            if (!suspect.Contains(pref + stmp) &&
                                (stmp.IndexOf(Constants.FIN_REP) >= 0 ||
                                 (maxGapHolds(getID(entry.Key), last_time, cstmp) &&
                                  maxGapHolds(getID(entry.Key), getInt(getID(entry.Key), cstmp).st_time,
                                              proj.Value.Value))))
                            {
                                suspect.Add(pref + stmp);
                            }
                            ind++;
                        }

                        /*
                         * List<string> toAdd = CoincidenceManager.getSymPartOfSlices
                         *  (CoincidenceManager.splitCoToSlices(seq_coes[i]));
                         * cur_coes[i] = seq_coes[i];
                         * fillSliceList(suspect, toAdd, cur_coes, patterns[entry.Key].Item1, getID(entry.Key), last_time);
                         */
                    }
                    //Add occurences of the slices that appeared in the current occurence of 'slice'
                    foreach (string sus in suspect)
                    {
                        if (ith_bef.ContainsKey(sus))
                        {
                            ith_bef[sus]++;
                        }
                        else
                        {
                            ith_bef.Add(sus, 1);
                        }
                    }
                    foreach (string sus in meet_suspect)
                    {
                        if (meet_ith_bef.ContainsKey(sus))
                        {
                            meet_ith_bef[sus]++;
                        }
                        else
                        {
                            meet_ith_bef.Add(sus, 1);
                        }
                    }
                    proj = canProjectBy(slice, seq_coes, patterns[entry.Key].Item1, getID(entry.Key), proj.Key, proj.Value.Value, last_time);
                    cpb  = proj.Key;
                }
            }
            //Take those that always appear
            List <string> ib = new List <string>();

            foreach (KeyValuePair <string, int> entry in ith_bef)
            {
                if (entry.Value == app_counter)
                {
                    string tmp = entry.Key[0] == Constants.MEET_REP || entry.Key[0] == Constants.CO_REP ?
                                 entry.Key.Substring(1) : entry.Key;
                    if (!ib.Contains(tmp))
                    {
                        ib.Add(tmp);
                    }
                }
            }
            foreach (KeyValuePair <string, int> entry in meet_ith_bef)
            {
                if (entry.Value == app_counter)
                {
                    string tmp = entry.Key[0] == Constants.MEET_REP || entry.Key[0] == Constants.CO_REP ?
                                 entry.Key.Substring(1) : entry.Key;
                    if (!ib.Contains(tmp))
                    {
                        ib.Add(tmp);
                    }
                }
            }
            return(ib);
        }
Пример #9
0
        // Projects the DB with insignificant slices removal iff check_ins = true (alpha is always a single slice)
        public TransformedDB projectDB(string alpha, Dictionary <string, int> ins_slices, bool check_ins)
        {
            KeyValuePair <int, KeyValuePair <List <string>, string> > proj;
            List <string> postfix;
            int           instance_counter = 0;
            //the new subids
            Dictionary <string, int> projSubids = new Dictionary <string, int>();
            //new db sequences
            Dictionary <string, List <string> > projDB = new Dictionary <string, List <string> >();
            //new extended patterns
            Dictionary <string, Tuple <string, int> > projPatterns = new Dictionary <string, Tuple <string, int> >();
            //Find the discovered patterns add figure out the real support
            List <string> patIDs = new List <string>();
            //For each co sequence in db
            int i = 0;

            foreach (KeyValuePair <string, List <string> > entry in trans_db)
            {
                i++;
                string ent_id = getID(entry.Key);
                if (!projSubids.ContainsKey(ent_id))
                {
                    projSubids.Add(ent_id, subids[ent_id]);
                }
                List <string> cleared = null;
                if (check_ins)
                {
                    cleared = CoincidenceManager.rem_ins_slices(entry.Value, ins_slices,
                                                                checkNextCoMeetOption(entry.Value, patterns[entry.Key].Item1));
                }
                int last_time = patterns[entry.Key].Item2;
                if (check_ins)
                {
                    proj = canProjectBy(alpha, cleared, patterns[entry.Key].Item1, ent_id, 0, "", last_time);
                }
                else
                {
                    proj = canProjectBy(alpha, entry.Value, patterns[entry.Key].Item1, ent_id, 0, "", last_time);
                }
                postfix = proj.Value.Key;
                if (postfix != null)
                {
                    projDB.Add(entry.Key, postfix);
                    int updated = getUpdatedEndTime(ent_id, last_time, proj.Value.Value);
                    projPatterns.Add(entry.Key, new Tuple <string, int>(patterns[entry.Key].Item1 + proj.Value.Value, updated));
                    if (!patIDs.Contains(ent_id))
                    {
                        patIDs.Add(ent_id);
                    }
                    bool stop  = false;
                    int  index = 0;
                    index = projSubids[ent_id];
                    List <string> prev_postfix;
                    string        prev_entry = entry.Key;
                    //Look for more occurences in the rest of the entity's sequence
                    while (!stop)
                    {
                        prev_postfix = postfix;
                        if (check_ins)
                        {
                            proj = canProjectBy(alpha, cleared, patterns[entry.Key].Item1, ent_id, proj.Key, proj.Value.Value, last_time);
                        }
                        else
                        {
                            proj = canProjectBy(alpha, entry.Value, patterns[entry.Key].Item1, ent_id, proj.Key, proj.Value.Value, last_time);
                        }
                        postfix = proj.Value.Key;
                        if (postfix != null)
                        {
                            prev_entry = ent_id + "." + index;
                            projDB.Add(prev_entry, postfix);
                            updated = getUpdatedEndTime(ent_id, last_time, proj.Value.Value);
                            projPatterns.Add(prev_entry, new Tuple <string, int>(patterns[entry.Key].Item1 + proj.Value.Value, updated));
                            if (!patIDs.Contains(ent_id))
                            {
                                patIDs.Add(ent_id);
                            }
                        }
                        else
                        {
                            stop = true;
                        }
                        index++;
                    }
                    projSubids[ent_id] = index;
                }
            }
            instance_counter = patIDs.Count;
            return(new TransformedDB(projDB, projPatterns, projSubids, alpha, instance_counter));
        }
Пример #10
0
        //The CBIDE algorithm
        private static void CBIDE(TransformedDB projDB, string alpha, int alpha_support,
                                  double totalsup, List <string> BS, ref CTP ctp, bool closed)
        {
            long dt1 = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond;
            Dictionary <string, int> LFs = projDB.slicesFreq();
            long          t     = DateTime.Now.Ticks / TimeSpan.TicksPerMillisecond - dt1;
            List <string> FS    = new List <string>();
            bool          start = false;

            if (closed)
            {
                foreach (KeyValuePair <string, int> entry in LFs)
                {
                    //CCMiner wanted only finishing ones, but that's not enough for closed patterns recognition
                    if (/*entry.Key.IndexOf(Constants.FIN_REP) > 0 &&*/ totalsup == entry.Value)
                    {
                        if (entry.Key[entry.Key.Length - 1] == Constants.ST_REP)
                        {
                            start = true;
                            break;
                        }
                        string slice = entry.Key[0] == Constants.MEET_REP || entry.Key[0] == Constants.CO_REP ?
                                       entry.Key.Substring(1) : entry.Key;
                        FS.Add(slice);
                    }
                }
            }
            //Check if none appear in pairs in BS U FS
            bool nip = closed && CoincidenceManager.noneInPairs(BS, FS);
            //Check if all appear in pairs in the accumulated coincidence
            bool aip = CoincidenceManager.allInPairs(alpha);

            //If So, there are no backward & forward extensions and this is a temporal pattern
            if ((!closed || (!start && nip)) && aip)
            {
                //Thus - alpha is a closed temporal pattern
                ctp.addPattern(alpha, alpha_support, projDB);
            }
            //Now Continue Looking for possible extensions
            List <string> P = new List <string>();

            //For each frequent slice:
            foreach (KeyValuePair <string, int> z in LFs)
            {
                if (z.Value < Constants.MINSUP)
                {
                    continue;
                }
                //Finishing slices only
                if (z.Key.IndexOf(Constants.FIN_REP) >= 0)
                {
                    string tmp = z.Key[0] == Constants.CO_REP ? z.Key.Substring(1) : z.Key;
                    if (alpha.IndexOf(tmp.Replace(Constants.FIN_REP, Constants.ST_REP)) >= 0)
                    {//pre-pruning
                        P.Add(z.Key);
                    }
                }
                else
                {
                    //Starting slices only
                    P.Add(z.Key);
                }
            }
            //For each possible extension we found:
            foreach (string z in P)
            {
                //post-pruning
                //Notice that we project another time only by the recent added slice
                TransformedDB alpha_projDB = projDB.projectDB(z, LFs, true);
                //If the support of the extended pattern is above the minimum support requested
                if (alpha_projDB.sup >= Constants.MINSUP)
                {
                    //Copy Backward extension list
                    List <string> BStag = BS.Take(BS.Count).ToList();
                    //Check if extensible and update the backward extension slices
                    if (!closed || !projDB.CBackScan(BStag, z))
                    {
                        if (closed)
                        {
                            BStag.AddRange(projDB.backwardExtensionCheck(z));
                        }
                        CBIDE(alpha_projDB, alpha + z, alpha_projDB.sup, alpha_projDB.trans_db.Count, BStag, ref ctp, closed);
                    }
                }
            }
        }
Пример #11
0
 //Sets the symbols of the pattern
 private void setSyms()
 {
     syms = CoincidenceManager.getSymbols(coSeqRep);
 }