Exemple #1
0
 private static MLArray CreateCellArray(string name, string[] names)
 {
     MLCell cell = new MLCell(name, new int[] {names.Length, 1});
     for (int i = 0; i < names.Length; i++)
         cell[i] = new MLChar(null, names[i]);
     return cell;
 }
 private static MLArray CreateCellArray()
 {
     string[] names = new string[] { "Hello", "World", "I am", "a", "MAT-file" };
     MLCell cell = new MLCell("Names", new int[] { names.Length, 1 });
     for (int i = 0; i < names.Length; i++)
         cell[i] = new MLChar(null, names[i]);
     return cell;
 }
Exemple #3
0
        private static MLCell CreateCellArrayCustom(string name, string[] items)
        {
            var cell = new MLCell(name, new int[] { items.Length, 1 });
            int i = 0;
            foreach (var item in items)
            {
                double ans = 0;
                if (double.TryParse(items[i], out ans))
                {
                    cell[i] = new MLDouble(null, new double[] { ans }, 1);
                    i++;
                    continue;
                }

                cell[i] = new MLChar(null, (string)items[i].Trim());

                i++;
            }
            return cell;
        }
Exemple #4
0
        static void DoWrite(string fn, Dictionary<string, DoubleList> data, SortedDictionary<string, double> param,
            List<MLArray> mlList, Hashtable seen)
        {
            log.Info("DoWrite start " + (GC.GetTotalMemory(false)/1024.0/1024.0));

            foreach (var item in data)
            {
                double[][] temp = item.Value.ToArray();
                MLArray dbarray = new MLDouble(item.Key, temp);
                mlList.Add(dbarray);
                log.Info("DoWrite " + item.Key + " " + (GC.GetTotalMemory(false)/1024.0/1024.0));
            }

            log.Info("DoWrite mllist " + (GC.GetTotalMemory(false)/1024.0/1024.0));

            MLCell cell = new MLCell("PARM", new int[] {param.Keys.Count, 2});
            int m = 0;
            foreach (var item in param.Keys)
            {
                cell[m, 0] = new MLChar(null, item.ToString());
                cell[m, 1] = new MLDouble(null, new double[] {(double) param[item]}, 1);
                m++;
            }

            mlList.Add(cell);

            MLArray seenmsg = CreateCellArray("Seen", seen.Keys.Cast<string>().ToArray());

            mlList.Add(seenmsg);

            try
            {
                log.Info("write " + fn + ".mat");
                log.Info("DoWrite before" + (GC.GetTotalMemory(false)/1024.0/1024.0));
                MatFileWriter mfw = new MatFileWriter(fn + ".mat", mlList, true);
                log.Info("DoWrite done" + (GC.GetTotalMemory(false)/1024.0/1024.0));
            }
            catch (Exception err)
            {
                CustomMessageBox.Show("There was an error when creating the MAT-file: \n" + err.ToString(),
                    "MAT-File Creation Error!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
        }
Exemple #5
0
        public static void log(string fn)
        {
            // read the file
            string[] filelines = File.ReadAllLines(fn);

            // store all the arrays
            List<MLArray> mlList = new List<MLArray>();
            // store data to putinto the arrays
            Dictionary<string, List<double[]>> data = new Dictionary<string, List<double[]>>();
            // store line item lengths
            Hashtable len = new Hashtable();
            // store whats we have seen in the log
            Hashtable seen = new Hashtable();
            // store the params seen
            SortedDictionary<string, double> param = new SortedDictionary<string, double>();

            // keep track of line no
            int a = 0;

            foreach (var line in filelines)
            {
                a++;
                Console.Write(a + "\r");

                string strLine = line.Replace(", ", ",");
                strLine = strLine.Replace(": ", ":");

                string[] items = strLine.Split(',', ':');

                // process the fmt messages
                if (line.StartsWith("FMT"))
                {
                    // +1 for line no
                    string[] names = new string[items.Length - 5 + 1];
                    names[0] = "LineNo";
                    Array.ConstrainedCopy(items, 5, names, 1, names.Length - 1);

                    MLArray format = CreateCellArray(items[3] + "_label", names);

                    if (items[3] == "PARM")
                    {

                    }
                    else
                    {
                        mlList.Add(format);
                    }

                    len[items[3]] = names.Length;
                } // process param messages
                else if (line.StartsWith("PARM"))
                {
                    param[items[1]] = double.Parse(items[2]);
                }// everyting else is generic
                else
                {
                    // make sure the line is long enough
                    if (items.Length < 2)
                        continue;
                    // check we have a valid fmt message for this message type
                    if (!len.ContainsKey(items[0]))
                        continue;
                    // check the fmt length matchs what the log has
                    if (items.Length != (int)len[items[0]])
                        continue;

                    // make it as being seen
                    seen[items[0]] = 1;

                    double[] dbarray = new double[items.Length];

                    // set line no
                    dbarray[0] = a;

                    for (int n = 1; n < items.Length; n++)
                    {
                        try
                        {
                            dbarray[n] = double.Parse(items[n]);
                        }
                        catch { }
                    }

                    if (!data.ContainsKey(items[0]))
                        data[items[0]] = new List<double[]>();

                    data[items[0]].Add(dbarray);
                }
            }

            foreach (var item in data)
            {
                double[][] temp = item.Value.ToArray();
                MLArray dbarray = new MLDouble(item.Key, temp);
                mlList.Add(dbarray);
            }

            MLCell cell = new MLCell("PARM", new int[] { param.Keys.Count, 2 });
            int m = 0;
            foreach (var item in param.Keys)
            {
                cell[m, 0] = new MLChar(null, item.ToString());
                cell[m, 1] = new MLDouble(null, new double[] { (double)param[item] }, 1);
                m++;
            }

            mlList.Add(cell);

            MLArray seenmsg = CreateCellArray("Seen", seen.Keys.Cast<string>().ToArray());

            mlList.Add(seenmsg);

            try
            {
                MatFileWriter mfw = new MatFileWriter(fn + ".mat", mlList, true);
            }
            catch (Exception err)
            {
                MessageBox.Show("There was an error when creating the MAT-file: \n" + err.ToString(),
                    "MAT-File Creation Error!", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
                return;
            }
        }
        /// <summary>
        /// Reads <c>miMATRIX</c> from the input stream.
        /// </summary>
        /// <remarks>
        /// If reading was not finished (which is normal for filtered results)
        /// returns <c>null</c>.
        /// </remarks>
        /// <param name="buf">The <c>BinaryReader</c> input stream.</param>
        /// <param name="isRoot">When <c>true</c> informs that if this is a top level
        /// matrix.</param>
        /// <returns><c>MLArray</c> or <c>null</c> if matrix does not match <c>filter</c></returns>
        private MLArray ReadMatrix( Stream buf, bool isRoot )
        {
            // result
            MLArray mlArray = null;
            ISMatTag tag;

            // read flags
            int[] flags = ReadFlags( buf );
            int attributes = (flags.Length != 0 ) ? flags[0] : 0;
            int nzmax = ( flags.Length != 0 ) ? flags[1] : 0;
            int type = attributes & 0xff;

            // read Array dimension
            int[] dims = ReadDimension( buf );

            // read Array name
            string name = ReadName( buf );

            // If this array is filtered out return immediately
            if( isRoot && !_filter.Matches(name) )
            {
                return null;
            }

            // read data
            switch (type)
            {
                case MLArray.mxSTRUCT_CLASS:
                    MLStructure mlStruct = new MLStructure(name, dims, type, attributes);

                    BinaryReader br = new BinaryReader(buf);

                    // field name length - this subelement always uses the compressed data element format
                    tag = new ISMatTag(br.BaseStream);
                    int maxlen = br.ReadInt32();

                    // Read fields data as Int8
                    tag = new ISMatTag(br.BaseStream);
                    // calculate number of fields
                    int numOfFields = tag.Size / maxlen;

                    // padding after field names
                    int padding = (tag.Size % 8) != 0 ? 8 - tag.Size % 8 : 0;

                    string[] fieldNames = new string[numOfFields];
                    for (int i = 0; i < numOfFields; i++)
                    {
                        byte[] names = new byte[maxlen];
                        br.Read(names, 0, names.Length);
                        fieldNames[i] = ZeroEndByteArrayToString(names);
                    }
                    br.ReadBytes(padding);

                    // read fields
                    for (int index = 0; index < mlStruct.M * mlStruct.N; index++)
                    {
                        for (int i = 0; i < numOfFields; i++)
                        {
                            // read matrix recursively
                            tag = new ISMatTag(br.BaseStream);
                            if (tag.Size > 0)
                            {
                                MLArray fieldValue = ReadMatrix(br.BaseStream, false);
                                mlStruct[fieldNames[i], index] = fieldValue;
                            }
                            else
                            {
                                mlStruct[fieldNames[i], index] = new MLEmptyArray();
                            }
                        }
                    }
                    mlArray = mlStruct;
                    //br.Close();
                    break;
                case MLArray.mxCELL_CLASS:
                    MLCell cell = new MLCell(name, dims, type, attributes);
                    for (int i = 0; i < cell.M * cell.N; i++)
                    {
                        tag = new ISMatTag(buf);
                        if (tag.Size > 0)
                        {
                            MLArray cellmatrix = ReadMatrix(buf, false);
                            cell[i] = cellmatrix;
                        }
                        else
                        {
                            cell[i] = new MLEmptyArray();
                        }
                    }
                    mlArray = cell;
                    break;
                case MLArray.mxDOUBLE_CLASS:
                    mlArray = new MLDouble(name, dims, type, attributes);
                    //read real
                    tag = new ISMatTag(buf);
                    tag.ReadToByteBuffer(((MLNumericArray<double>)mlArray).RealByteBuffer,
                        (ByteStorageSupport)mlArray);

                    // read complex
                    if (mlArray.IsComplex)
                    {
                        tag = new ISMatTag(buf);
                        tag.ReadToByteBuffer(((MLNumericArray<double>)mlArray).ImaginaryByteBuffer,
                            (ByteStorageSupport)mlArray);
                    }
                    break;
                case MLArray.mxUINT8_CLASS:
                    mlArray = new MLUInt8(name, dims, type, attributes);
                    //read real
                    tag = new ISMatTag(buf);
                    tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).RealByteBuffer,
                        (ByteStorageSupport)mlArray);

                    // read complex
                    if (mlArray.IsComplex)
                    {
                        tag = new ISMatTag(buf);
                        tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).ImaginaryByteBuffer,
                            (ByteStorageSupport)mlArray);
                    }
                    break;
                case MLArray.mxINT8_CLASS:
                    mlArray = new MLInt8(name, dims, type, attributes);
                    //read real
                    tag = new ISMatTag(buf);
                    tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).RealByteBuffer,
                        (ByteStorageSupport)mlArray);

                    // read complex
                    if (mlArray.IsComplex)
                    {
                        tag = new ISMatTag(buf);
                        tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).ImaginaryByteBuffer,
                            (ByteStorageSupport)mlArray);
                    }
                    break;
                case MLArray.mxUINT64_CLASS:
                    mlArray = new MLUInt64(name, dims, type, attributes);
                    //read real
                    tag = new ISMatTag(buf);
                    tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).RealByteBuffer,
                        (ByteStorageSupport)mlArray);

                    // read complex
                    if (mlArray.IsComplex)
                    {
                        tag = new ISMatTag(buf);
                        tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).ImaginaryByteBuffer,
                            (ByteStorageSupport)mlArray);
                    }
                    break;
                case MLArray.mxINT64_CLASS:
                    mlArray = new MLInt64(name, dims, type, attributes);
                    //read real
                    tag = new ISMatTag(buf);
                    tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).RealByteBuffer,
                        (ByteStorageSupport)mlArray);

                    // read complex
                    if (mlArray.IsComplex)
                    {
                        tag = new ISMatTag(buf);
                        tag.ReadToByteBuffer(((MLNumericArray<byte>)mlArray).ImaginaryByteBuffer,
                            (ByteStorageSupport)mlArray);
                    }
                    break;
                case MLArray.mxCHAR_CLASS:
                    MLChar mlchar = new MLChar(name, dims, type, attributes);
                    //read real
                    tag = new ISMatTag(buf);
                    char[] ac = tag.ReadToCharArray();
                    for (int i = 0; i < ac.Length; i++)
                    {
                        mlchar.SetChar(ac[i], i);
                    }
                    mlArray = mlchar;
                    break;
                case MLArray.mxSPARSE_CLASS:
                    MLSparse sparse = new MLSparse(name, dims, attributes, nzmax);

                    // read ir (row indices)
                    tag = new ISMatTag(buf);
                    int[] ir = tag.ReadToIntArray();
                    // read jc (column indices)
                    tag = new ISMatTag(buf);
                    int[] jc = tag.ReadToIntArray();

                    // read pr (real part)
                    tag = new ISMatTag(buf);
                    double[] ad1 = tag.ReadToDoubleArray();
                    int n = 0;
                    for (int i = 0; i < ir.Length; i++)
                    {
                        if (i < sparse.N)
                        {
                            n = jc[i];
                        }
                        sparse.SetReal(ad1[i], ir[i], n);
                    }

                    //read pi (imaginary part)
                    if (sparse.IsComplex)
                    {
                        tag = new ISMatTag(buf);
                        double[] ad2 = tag.ReadToDoubleArray();

                        int n1 = 0;
                        for (int i = 0; i < ir.Length; i++)
                        {
                            if (i < sparse.N)
                            {
                                n1 = jc[i];
                            }
                            sparse.SetImaginary(ad2[i], ir[i], n1);
                        }
                    }
                    mlArray = sparse;
                    break;
                default:
                    throw new MatlabIOException("Incorrect Matlab array class: " + MLArray.TypeToString(type));
            }
            return mlArray;
        }