コード例 #1
0
        public static void InsectExperiment()
        {
            Index <Meta3DataFormat> si = Index <Meta3DataFormat> .Load(Globals.IndexRootDir);

            string queryFile = @"C:\Temp\insect\queries.txt";

            List <double[]> queries = Util.ReadFiletoDoubleList(queryFile, true);

            using (StreamWriter sw = new StreamWriter(@"C:\Temp\insect\output.txt"))
            {
                for (int i = 0; i < queries.Count; ++i)
                {
                    if (queries[i].Length != Globals.TimeSeriesLength)
                    {
                        throw new ApplicationException("queries[i].Length != Globals.TimeSeriesLength");
                    }

                    TermEntry res = si.ApproximateSearch(queries[i]);
                    Console.WriteLine("Query:{0} FileName:{1}", i, res.FileName);

                    List <Meta3DataFormat> metas = si.ReturnDataFormatFromTermEntry(res);
                    double          bsf          = Double.MaxValue;
                    Meta3DataFormat bsfMeta      = new Meta3DataFormat();
                    foreach (Meta3DataFormat m in metas)
                    {
                        double dist = Util.EuclideanDistance(m.GetTimeSeries(), queries[i]);
                        if (dist < bsf)
                        {
                            bsf     = dist;
                            bsfMeta = m;
                        }
                    }
                    Console.WriteLine("BsfDist:{0} Meta1:{1} Meta2:{2}", bsf, bsfMeta.meta1, bsfMeta.meta2);
                    sw.WriteLine(Util.ArrayToString(queries[i]));
                    sw.WriteLine(Util.ArrayToString(bsfMeta.GetTimeSeries()));
                }
            }
        }
コード例 #2
0
        public override void LoadIndex()
        {
            ushort     maskval = (ushort)(Math.Log(Globals.SaxMaxCard, 2) - Math.Log(Globals.SaxBaseCard, 2));
            SaxOptions opts    = new SaxOptions(Util.UnsignedShortArray(Globals.SaxWordLength, maskval));

            double[]    dataBuffer;
            IDataFormat dl;

            double[] ts;
            int      discarded = 0;

            string[] files = Directory.GetFiles(_dataDir, "*.dat");
            Array.Sort(files, new NaturalStringComparer());

            if (files.Length != NUMFILES)
            {
                throw new ApplicationException("numFiles != NUMFILES");
            }

            StringBuilder sb = new StringBuilder();

            sb.AppendLine("File => Number Mapping");

            for (int i = 0; i < NUMFILES; ++i)
            {
                string file = files[i];
                sb.AppendFormat("{0} => {1}", Path.GetFileNameWithoutExtension(file), i);
                Console.WriteLine("Processed:{2} Discarded:{0} AtFile:{1}", discarded, file, processed);

                if (!File.Exists(file))
                {
                    throw new ApplicationException("!File.Exists(file)");
                }

                // read data file into memory
                using (BinaryReader br = new BinaryReader(new FileStream(file, FileMode.Open, FileAccess.Read, FileShare.None, 100000000)))
                {
                    if (Math.IEEERemainder(br.BaseStream.Length, sizeof(double)) != 0)
                    {
                        throw new ApplicationException("Math.IEEERemainder( br.BaseStream.Length, sizeof(double)) != 0");
                    }

                    dataBuffer = new double[br.BaseStream.Length / sizeof(double)];
                    int offset = 0;

                    for (int pos = 0; pos < br.BaseStream.Length; pos += sizeof(double))
                    {
                        dataBuffer[offset++] = br.ReadDouble();
                    }
                }

                // sliding window and extract time series subsequences

                for (int pos = 0; pos < dataBuffer.Length - Globals.TimeSeriesLength; ++pos)
                {
                    ts = new double[Globals.TimeSeriesLength];
                    Array.Copy(dataBuffer, pos, ts, 0, Globals.TimeSeriesLength);

                    // filter
                    double std = Util.StdDev(ts);
                    if (std <= FILTERVAL)
                    {
                        discarded += (int)Math.Ceiling(Globals.TimeSeriesLength / 2.0) + 1;
                        pos       += (int)Math.Ceiling(Globals.TimeSeriesLength / 2.0);
                        continue;
                    }
                    else
                    {
                        // normalize
                        double mean = Util.Mean(ts, 0, ts.Length - 1);
                        for (int j = 0; j < ts.Length; ++j)
                        {
                            ts[j] = (ts[j] - mean) / std;
                        }

                        dl = new Meta3DataFormat(i, pos, ts);
                        _si.Insert(new SaxData(dl, Sax.ArrayToSaxVals(ts, opts)));
                        processed++;

                        if (processed % Globals.FlushTsVal == 0)
                        {
                            _si.FlushEntries();
                        }
                    }
                }

                GC.Collect();
            }
            _si.FlushEntries();

            Console.WriteLine();
            Console.WriteLine(sb.ToString());
            Console.WriteLine();
            Console.WriteLine("Processed:{0} {1}", processed, _si.NumTimeSeries);
            Console.WriteLine("Discarded:{0}", discarded);
            Console.WriteLine();
        }