Text Parser for C#

i'm trying to read lrc file (lyrics)

here is my code:

 StreamReader lReader = new StreamReader(new FileStream(@"...",<br />
                           FileMode.Open, FileAccess.Read, FileShare.Read), Encoding.UTF8);<br />
<br />
            ZCU.IO.TextParser parser = new ZCU.IO.TextParser(lReader);<br />
            uint numLines = parser.ReadUInt32(); // first line of lrc file must be a count of all lines in file<br />
                string line = parser.ReadLine();<br />
                ZCU.IO.TextParser line_parser = new ZCU.IO.TextParser(line);<br />
                string format = "[%f:%f]%s.\n"; // '.' required if we want to read all words in line, not only first word.<br />
                object[] lyrics = new object[3];<br />
                line_parser.Scanf(format, lyrics);<br />
                List<string> formatList = ZCU.IO.TextParser.ConstructFormatList(format);<br />
                textBox1.Text += lyrics[0].ToString() + lyrics[1].ToString() + lyrics[2].ToString() + "\n";<br />
                for (uint i = 1; i < numLines; i++)<br />
                {<br />
                    parser.Scanf(formatList, lyrics);<br />
                    textBox1.Text += lyrics[0].ToString() + lyrics[1].ToString() + lyrics[2].ToString() + "\n";<br />
                }</string>

But it printes 14 (or whatever number numLines defines) identical lines (first line which was read from file, ex. [0:10]First line of text here)

Guys I'm very stuck.I've searched the web for the past three weeks for a class written in C# that has low pass, high pass, Band pass filters which I could used for my third year project data analysis. I'm very desperate and my eyes are bloody red right now due to lack sleep; please help...

I believe there are alot of geniuses in this forum who cannot be stopped by anything..Looking forward to receiving your help...
Cheers
The followings are two classes that I found on the web but I don't understand where they get Series from. Please have a look to see if you can help me modify the classes...

<code//=================================================================
//  File:		FIRFilters.cs
//
//  Namespace:	Dundas.Charting.Utilities
//
//	Classes:	FIRFilters, FFT
//
//  Purpose:	Used to perform digital filters on charts
//
//===================================================================
// Dundas Chart Control .Net
// Copyright © Dundas Software 2001-2005, all rights reserved
//===================================================================

using System;
using System.Collections.Generic;
using System.Text;
using Dundas.Charting.Utilities;//WinControl;

namespace Dundas.Charting.Utilities
{
    /// <summary>
    /// Helper class which implements the filtering functions. Currently Low Pass, High Pass and
    /// Band Pass are implemented.
    /// </summary>
    class FIRFilters
    {
        #region Members
        /// <summary>
        /// The number of samples is the same as the number of points
        /// </summary>
        private int mySamples;

        /// <summary>
        /// Holds the coefficient from the window function
        /// </summary>
        private float[] myCoeff;

        /// <summary>
        /// Holds the series which has the input data
        /// </summary>
        private Series myInputSeries;

        /// <summary>
        /// Holds the series which we are outputting to
        /// </summary>
        private Series myFilterSeries;

        /// <summary>
        /// FFT algorithm object
        /// </summary>
        private FFT myFFT;

        /// <summary>
        /// Holds the current algorithm selected. Enumeration type is drawn from the FFT object.
        /// </summary>
        public FFT.Algorithm CurrentAlgorithm;

        private float myFreqFrom;
        private float myFreqTo;
        private float myAttenuation;
        private float myBand;
        private float myAlpha;
        private int myTaps;
        private int myOrder;
        #endregion

        #region Properties
        /// <summary>
        /// The starting passband frequency, must be lower than ending frequency.
        /// </summary>
        public float FreqFrom
        {
            get { return myFreqFrom; }
            set { myFreqFrom = value; }
        }

        /// <summary>
        /// The ending passband frequency, must be higher than starting frequency.
        /// </summary>
        public float FreqTo
        {
            get { return myFreqTo; }
            set { myFreqTo = value; }
        }

        /// <summary>
        /// Stopband attenuation
        /// </summary>
        public float StopBandAttenuation
        {
            get { return myAttenuation; }
            set {
                    myAttenuation = value;
                    this.myFFT.StopBandAttenuation = myAttenuation;
                }
        }

        /// <summary>
        /// Transition band
        /// </summary>
        public float TransitionBand
        {
            get { return myBand; }
            set {
                    myBand = value;
                    this.myFFT.TransitionBand = myBand;
                }
        }

        /// <summary>
        /// Alpha value used for the Kaiser algorithm.
        /// </summary>
        public float Alpha
        {
            get { return myAlpha; }
            set {
                    myAlpha = value;
                    this.myFFT.Alpha = myAlpha;
                }
        }

        /// <summary>
        /// Number of taps to be used. Taps is the number of samples processed at any one time.
        /// </summary>
        public int Taps
        {
            get { return myTaps; }
            set { myTaps = value; }
        }

        /// <summary>
        /// Filter order. Must be an even number.
        /// </summary>
        public int Order
        {
            get { return myOrder; }
            set
            {
                //Assure value is even
                if ((value % 2) == 0)
                {
                    myOrder = value;
                    this.myFFT.Order = myOrder;
                }
                else
                    throw new ArgumentOutOfRangeException("Order", "Filter order must be an even number.");
            }
        }
        #endregion

        #region Constructors
        /// <summary>
        /// Main constructor. Resets all settings within the FFT algorithm object.
        /// </summary>
        public FIRFilters()
        {
            //Create a new FFT object
            this.myFFT = new FFT();

            //Default algorithm to Kaiser
            this.CurrentAlgorithm = FFT.Algorithm.Kaiser;

            //Default taps to 35
            this.myTaps = 35;
        }
        #endregion

        #region Methods
        /// <summary>
        /// Performs a low pass filter. Output series will be cleared before being
        /// output to. If passband start and end frequencies are left at 0, defaults are used.
        /// </summary>
        /// <param name="iseries">Input series that contains input data. Input Y-Values must be contained in YValues[0] or unexpected output will occur</param>
        /// <param name="oseries">Output series to which filter will be written. Output Y-Values are written to YValues[0]</param>
        public void LowPassFilter(Series iseries, Series oseries)
        {
            //If no start and end frequencies are specified, default low pass frequency range to:
            //0 - 1000hz
            if (this.myFreqFrom == 0.0f && this.myFreqTo == 0.0f)
            {
                this.myFFT.FreqFrom = 0.0f;
                this.myFFT.FreqTo = 1000.0f;
            }
            else
            {
                this.myFFT.FreqFrom = this.myFreqFrom;
                this.myFFT.FreqTo = this.myFreqTo;
            }

            //Generate the actual coefficients
            this.myCoeff = this.myFFT.GenerateCoefficients(FFT.FilterType.LowPass, CurrentAlgorithm);

            //Filter the series based on the coefficients generated
            Filter(iseries, oseries);
        }

        /// <summary>
        /// Performs a high pass filter. Output series will be cleared before being
        /// output to. If passband start and end frequencies are left at 0, defaults are used.
        /// </summary>
        /// <param name="iseries">Input series that contains input data. Input Y-Values must be contained in YValues[0] or unexpected output will occur</param>
        /// <param name="oseries">Output series to which filter will be written. Output Y-Values are written to YValues[0]</param>
        public void HighPassFilter(Series iseries, Seriesoseries)
        {
            //If no start and end frequencies are specified, default high pass frequency range to:
            //2000 - 4000hz
            if (this.myFreqFrom == 0.0f && this.myFreqTo == 0.0f)
            {
                this.myFFT.FreqFrom = 2000.0f;
                this.myFFT.FreqTo = 4000.0f;
            }
            else
            {
                this.myFFT.FreqFrom = this.myFreqFrom;
                this.myFFT.FreqTo = this.myFreqTo;
            }

            //Generate the actual coefficients
            this.myCoeff = this.myFFT.GenerateCoefficients(FFT.FilterType.HighPass, CurrentAlgorithm);

            //Filter the series based on the coefficients generated
            Filter(iseries, oseries);
        }

        /// <summary>
        /// Performs a band pass filter. Output series will be cleared before being
        /// output to. If passband start and end frequencies are left at 0, defaults are used.
        /// </summary>
        /// <param name="iseries">Input series that contains input data. Input Y-Values must be contained in YValues[0] or unexpected output will occur</param>
        /// <param name="oseries">Output series to which filter will be written. Output Y-Values are written to YValues[0]</param>
        public void BandPassFilter(Series iseries, Series oseries)
        {
            //If no start and end frequencies are specified, default band pass frequency range to:
            //1000 - 1000hz
            if (this.myFreqFrom == 0.0f && this.myFreqTo == 0.0f)
            {
                this.myFFT.FreqFrom = 1000.0f;
                this.myFFT.FreqTo = 1000.0f;
            }
            else
            {
                this.myFFT.FreqFrom = this.myFreqFrom;
                this.myFFT.FreqTo = this.myFreqTo;
            }

            //Generate the actual coefficients
            this.myCoeff = this.myFFT.GenerateCoefficients(FFT.FilterType.BandPass, CurrentAlgorithm);

            //Filter the series based on the coefficients generated
            Filter(iseries, oseries);
        }
        #endregion

        #region Initialization
        /// <summary>
        /// Initializes the FIRFilters object by setting the input and output series members for use
        /// by the filter.
        /// </summary>
        /// <param name="iseries">Input series that contains input data</param>
        /// <param name="oseries">Output series to which filter will be written</param>
        private void SetIOSeries(Series iseries, Series oseries)
        {
            this.myInputSeries = iseries;
            this.myFilterSeries = oseries;

            //Samples is the number of points contained in the input
            this.mySamples = myInputSeries.count;
        }
        #endregion

        #region Filter
        /// <summary>
        /// Performs the actual filter. Coefficients should have already be generated by the calling
        /// function, this function merely applies them and physically adds the points to the output series.
        /// </summary>
        /// <param name="iseries">Input series that contains input data</param>
        /// <param name="oseries">Output series to which filter will be written</param>
        private void Filter(float[] iseries, List<float> oseries)
        {
            float[] x = new float[myTaps];
            float y;

            //Set the series
            SetIOSeries(iseries, oseries);
            
            //Clear series
            myFilterSeries.Clear();

            //Initialize x
            for (int i = 1; i < myTaps; i++)
                x[i] = 0.0f;

            //Loop through every data point
            for (int i = 0; i < mySamples; i++)
            {
                //Initialize y
                y = 0.0f;

                //Obtain the data value (Y value) at the specified X value (i)
                x[0] = Convert.ToSingle(myInputSeries[i]);

                //Loop through from 0 to number of taps and calculate the sum
                try
                {
                    for (int j = 0; j < myTaps; j++)
                        y = y + (x[j] * myCoeff[j]);
                }
                catch (Exception e)
                {
                    System.Diagnostics.Debug.WriteLine(e.Message + " Check filter order.");
                    throw;
                }

                //Shift all x values by 1 to the right
                for (int j = myTaps - 1; j > 0; j--)
                    x[j] = x[j - 1];

                //Add the y value to the output series at the current x value
                myFilterSeries.Add(new Dundas.Charting.DataPoint(i, y));
            }
        }
        #endregion
    }
}

<pre>
//=================================================================
//  File:		FFT.cs
//
//  Namespace:	Dundas.Charting.Utilities
//
//	Classes:	FFT
//
//  Purpose:	Used for the fast fourier transformation algorithm
//
//===================================================================
// Dundas Chart Control .Net
// Copyright © Dundas Software 2001-2005, all rights reserved
//===================================================================

using System;
using System.Collections.Generic;
using System.Text;

namespace Dundas.Charting.Utilities
{
    /// <summary>
    /// Helper class which implements the various window functions for determination of the filter
    /// coefficients.
    /// </summary>
    class FFT
    {
        #region Members
        /// <summary>
        /// Filter type enumeration for identification of what type of filter we want coefficients
        /// for.
        /// </summary>
        public enum FilterType { HighPass, LowPass, BandPass };

        /// <summary>
        /// Algorithm enumeration for choice of algorithm
        /// </summary>
        public enum Algorithm { Kaiser, Hann, Hamming, Blackman, Rectangular };

        private float myRate;
        private float myFreqFrom;
        private float myFreqTo;
        private float myAttenuation;
        private float myBand;
        private float myAlpha;
        private int myOrder;

        /// <summary>
        /// Shannon sampling frequency
        /// </summary>
        private float myFS;
        #endregion

        #region Properties
        /// <summary>
        /// Sampling rate
        /// </summary>
        public float Rate
        {
            get { return myRate; }
            set
            {
                myRate = value;
                myFS = 0.5f * myRate;
            }
        }

        /// <summary>
        /// Starting frequency for passband. Must be lower than the ending frequency.
        /// </summary>
        public float FreqFrom
        {
            get { return myFreqFrom; }
            set { myFreqFrom = value; }
        }

        /// <summary>
        /// Ending frequency for passband. Must be higher than the starting frequency.
        /// </summary>
        public float FreqTo
        {
            get { return myFreqTo; }
            set { myFreqTo = value; }
        }

        /// <summary>
        /// Stopband attenuation.
        /// </summary>
        public float StopBandAttenuation
        {
            get { return myAttenuation; }
            set { myAttenuation = value; }
        }

        /// <summary>
        /// Transition band.
        /// </summary>
        public float TransitionBand
        {
            get { return myBand; }
            set { myBand = value; }
        }

        /// <summary>
        /// Alpha value used for the Kaiser algorithm.
        /// </summary>
        public float Alpha
        {
            get { return myAlpha; }
            set { myAlpha = value; }
        }

        /// <summary>
        /// Filter order. Must be an even number.
        /// </summary>
        public int Order
        {
            get { return myOrder; }
            set { myOrder = value; }
        }
        #endregion

        #region Constructors
        /// <summary>
        /// Construct a FFT instance and initialize with default values.
        /// </summary>
        public FFT()
        {
            //default rate to 8000
            Rate = 8000;

            //default attenuation to 60db
            this.myAttenuation = 60;

            //default transition band to 500hz
            this.myBand = 500;

            //default order to 0 so that we'll know if it was changed by the user or not
            this.myOrder = 0;

            //default Alpha to 4
            this.myAlpha = 4;
        }
        #endregion

        #region Mathematical Functions
        /// <summary>
        /// Bessel is the zeroth order Bessel function which is used in the Kaiser window.
        /// This is a polynomial approximation of the zeroth order modified Bessel function found in:
        /// W.H. Press, B.P. Flannery, S.A. Teukolsky, and W.T. Vetterling.
        /// Numerical Recipes in C: The Art of Scientific Computing.
        /// Cambridge UP, 1988.
        /// P. 237
        /// </summary>
        /// <param name="x">Input number which the Bessel will be performed on</param>
        private float Bessel(float x)
        {
            double ax, ans;
            double y;

            ax = System.Math.Abs(x);
            if (ax < 3.75)
            {
                y = x / 3.75;
                y *= y;
                ans = 1.0 + y * (3.5156229 + y * (3.0899424 + y * (1.2067492
                    + y * (0.2659732 + y * (0.360768e-1 + y * 0.45813e-2)))));
            }
            else
            {
                y = 3.75 / ax;
                ans = (System.Math.Exp(ax) / System.Math.Sqrt(ax)) * (0.39894228 + y * (0.1328592e-1
                    + y * (0.225319e-2 + y * (-0.157565e-2 + y * (0.916281e-2
                    + y * (-0.2057706e-1 + y * (0.2635537e-1 + y * (-0.1647633e-1
                    + y * 0.392377e-2))))))));
            }

            return (float)ans;
        }
        #endregion

        #region Generate Coefficients
        /// <summary>
        /// Calculate the coefficients to be used by the filter function.
        /// </summary>
        /// <param name="filterType">Enum type which specifies the filter to be performed.</param>
        /// <param name="alg">Enum type which specifies which algorithm to be used for the window
        /// algorithm.</param>
        public float[] GenerateCoefficients(FilterType filterType, Algorithm alg)
        {
            //Calculate order if it hasn't been set
            if (this.myOrder == 0)
                this.myOrder = (int)(((this.myAttenuation - 7.95f) / (this.myBand * 14.36f / this.myFS) + 1.0f) * 2.0f) - 1;

            float[] window = new float[(this.myOrder / 2) + 1];
            float[] coEff = new float[this.myOrder + 1];
            float ps;
            float pe;
            const float PI = (float)System.Math.PI;
            int o2 = this.myOrder / 2;

            //Switch based on algorithm
            switch (alg)
            {
                case Algorithm.Kaiser:
                    //Kaiser Window function
                    for (int i = 1; i <= o2; i++)
                    {
                        window[i] = Bessel(this.myAlpha * (float)System.Math.Sqrt(1.0f - (float)System.Math.Pow((float)i / o2, 2))) / Bessel(this.myAlpha);
                    }

                    //Stopband attenuation and transition band should be set by the user
                    break;

                case Algorithm.Hann:
                    //Hann window function
                    for (int i = 1; i <= o2; i++)
                    {
                        window[i] = 0.5f + 0.5f * (float)System.Math.Cos((PI / (o2 + 1)) * i);
                    }

                    //Set the min stopband attenuation
                    this.StopBandAttenuation = 44.0f;

                    //Set the transition band
                    this.TransitionBand = 6.22f * this.myFS / this.myOrder;
                    break;

                case Algorithm.Hamming:
                    //Hamming window function
                    for (int i = 1; i <= o2; i++)
                    {
                        window[i] = 0.54f + 0.46f * (float)System.Math.Cos((PI / o2) * i);
                    }

                    //Set the min stopband attenuation
                    this.StopBandAttenuation = 53.0f;

                    //Set the transition band
                    this.TransitionBand = 6.64f * this.myFS / this.myOrder;
                    break;

                case Algorithm.Blackman:
                    //Blackman window function
                    for (int i = 1; i <= o2; i++)
                    {
                        window[i] = 0.42f + 0.5f * (float)Math.Cos((PI / o2) * i) + 0.08f * (float)Math.Cos(2.0f * (PI / o2) * i);
                    }

                    //Set the min stopband attenuation
                    this.StopBandAttenuation = 74.0f;

                    //Set the transition band
                    this.TransitionBand = 11.13f * this.myFS / this.myOrder;
                    break;

                case Algorithm.Rectangular:
                    //Rectangular window function
                    for (int i = 1; i <= o2; i++)
                    {
                        window[i] = 1.0f;
                    }

                    //Set the min stopband attenuation
                    this.StopBandAttenuation = 21.0f;

                    //Set the transition band
                    this.TransitionBand = 1.84f * this.myFS / this.myOrder;
                    break;

                default:
                    //Zero all values if nothing was set (error)
                    for (int i = 1; i <= o2; i++)
                    {
                        window[i] = 0.0f;
                    }
                    break;
            }

            //Switch based on filtertype
            switch (filterType)
            {
                case FilterType.BandPass:
                    pe = PI / 2 * (this.FreqTo - this.FreqFrom + this.myBand) / this.myFS;
                    ps = PI / 2 * (this.FreqFrom + this.FreqTo) / this.myFS;
                    break;

                case FilterType.LowPass:
                    pe = PI * (this.FreqTo + this.myBand / 2) / this.myFS;
                    ps = 0.0f;
                    break;

                case FilterType.HighPass:
                    pe = PI * (1.0f - (this.FreqFrom - this.myBand / 2) / this.myFS);
                    ps = PI;
                    break;

                default:
                    pe = 0.0f;
                    ps = 0.0f;
                    break;
            }

            //Set first coefficient value
            coEff[0] = pe / PI;

            //Calculate coefficientsw
            for (int i = 1; i <= o2; i++)
            {
                coEff[i] = window[i] * (float)System.Math.Sin(i * pe) * (float)System.Math.Cos(i * ps)  / (i * PI);
            }

            //Shift Impulse
            for (int i = o2 + 1; i <= this.myOrder; i++)
            {
                coEff[i] = coEff[i - o2];
            }
            for (int i = 0; i <= o2 - 1; i++)
            {
                coEff[i] = coEff[this.myOrder - i];
            }
            coEff[o2] = pe / PI;

            return coEff;
        }
        #endregion
    }
}

kel

I'm desperate needing your help...God bless

kel

I've trying to read a .txt files in order to plot the data on a ZedGraph. The problem is I cannot convert the data to double. The compiler gives bunch of errors(Error 1 Cannot convert type 'string' to 'double'). The following is a piece of code that i'm having trouble with.

private void BRead(GraphPane myPane)
{
FileStream fleReader = new FileStream("kel.txt", FileMode.Open, FileAccess.Read);
StreamReader stmReader = new StreamReader(fleReader);
StringBuilder lstChars = new StringBuilder();
double x = 0, y;
int iChar = stmReader.Read();
lstChars.Append((char)iChar);

// double[] yx = new double[lstChars.Length];
PointPairList list = new PointPairList();
while (iChar > -1)
{
x = x + (double)0.0002;
iChar = stmReader.Read();
lstChars.Append((char)iChar);
y = (double)(lstChars.ToString()); //error
list.Add(x, y);
}

this.textBox1.Text = lstChars.ToString();
stmReader.Close();

CurveItem myCurve = myPane.AddCurve("My Curve",list, Color.Red, SymbolType.Diamond);
}

can anyone help me please!!

To convert string to double use y = Double.Parse(lstChars.ToString()). Btw your while cycle is suspicious. I do not know the structure of your "kel.txt" file, but let me assume it contains one double per one line. Thus in order to read it, you would need the following code:

string line;
while ((line = stmReader.ReadLine()) != null)
{
x = x + (double)0.0002;
y = Double.Parse(line);
list.Add(x, y);
}

or using the library proposed here:
System.Double o_y = new System.Double();

ZCU.IO.TextParser parser = new ZCU.IO.TextParser(stmReader);
while (parser.Scanf("%f", o_y) > 0)
{
x = x + (double)0.0002;
list.Add(x, o_y);
}

BeSoft

Thank you very much for your support. Here is sum data contained in kel.txt;

Freq (Hz) CH2 PSD (G^2/Hz)
6.10E-03 1.23E-04
1.22E-02 2.35E-06
1.83E-02 6.70E-05
2.44E-02 3.40E-04
3.05E-02 8.71E-05
3.66E-02 3.21E-05
4.27E-02 3.95E-05
4.88E-02 6.34E-05
5.49E-02 6.60E-05
6.10E-02 2.35E-05
6.71E-02 2.00E-05
7.32E-02 4.02E-06
7.93E-02 2.91E-06
8.54E-02 9.96E-07
9.16E-02 5.42E-05
9.77E-02 1.53E-04
1.04E-01 1.42E-04

first of all I wanted to read in the first column(Freq (Hz)) and store in say double[] array_x, and the second column (CH2 PSD (G^2/Hz)) and save it in double[] array_y.

and to plot it i would want to do the following:

list.Add(array_x, array_y);
CurveItem myCurve = myPane.AddCurve("My Curve", list, Color.Red, SymbolType.Diamond);
.......................................................................................
I know that the first column will always be an even index while the second will be an odd index (considering 0)
{
int i=0
i.e. double[]array_x ;//even
double[] array_y;

string line;

{

for(int x=0; x

ReadToEnd reads the whole file while ReadLine reads one line only.

So which is the best way forward given the fact that I wanted to store frequency data(first column) on arr1 and second column data on arr2?
thanks

if you prefer to use pure .NET 2.0 code, you can use the following code:

FileStream fleReader = new FileStream("kel.txt", FileMode.Open, FileAccess.Read);
StreamReader stmReader = new StreamReader(fleReader);

string line = stmReader.ReadLine(); //skip header

List<double> lst_x = new List<double>();
List<double> lst_y = new List<double>();

char[] delims = new char[] { ' ', '\t' };
while ((line = stmReader.ReadLine()) != null)
{
string[] pole = line.Split(delims, StringSplitOptions.RemoveEmptyEntries);
lst_x.Add(Double.Parse(pole[0]));
lst_y.Add(Double.Parse(pole[1]));
}

double[] arr1 = lst_x.ToArray();
double[] arr2 = lst_y.ToArray();

PS: List<t> is in System.Collections.Generic namespace

BeSoft

Thanks again for your help. I've sum few questions though. The compiler complains with
List lst_x=new List();
List lst_x=new List();

did you mean
ArrayList lst_x = new ArrayList();
and ArrayList lst_y = new ArrayList();?

The compiler also complains of the following lines:
double[] arr1 = lst_x.ToArray();//error
double[] arr2 = lst_y.ToArray();//error

Once those errors are corrected, can i plot the data as shown below?
list.Add(arr1, arr2);
CurveItem myCurve = myPane.AddCurve("My Curve", list, Color.Red, SymbolType.Diamond);

Thanks for your help once again.

...................................................................

FileStream fleReader = new FileStream("kel.txt", FileMode.Open, FileAccess.Read);
StreamReader stmReader = new StreamReader(fleReader);

string line = stmReader.ReadLine(); //skip header

List lst_x = new List();
List lst_y = new List();

char[] delims = new char[] { ' ', '\t' };
while ((line = stmReader.ReadLine()) != null)
{
string[] pole = line.Split(delims, StringSplitOptions.RemoveEmptyEntries);
lst_x.Add(Double.Parse(pole[0]));
lst_y.Add(Double.Parse(pole[1]));
}

double[] arr1 = lst_x.ToArray();
double[] arr2 = lst_y.ToArray();

Oops, the script behind trimmed special characters from my reply. I ment: List<double>, which is in System.Collections.Generic namespace.

You are a genius my friend. Thanks alot BeSoft for your help...

kel

I have had a hell of a time finding a parser library that is able to parse a syslog file. Is this possible with this library and if so could you post an example of how to do it? There are a ton of libraries that will read other formats into syslog but I can't find any that will take syslog format as input.

Text Parser for C#

Introduction

Using the Code

Input file 1

Input file 2

Points of Interest

History

License

Comments and Discussions