Как прочитать из файла данные в List<double>

public List<Double> Basis_Haara(List<Double> f)
        {
            int M = 5;
            int Nx = 1;
            for (int i = 1; i <= M; i++)
            Nx *= 2;
            Nx = 4 * Nx;
            M += 2;
 
            //double[] f;// = new double[Nx];
 
 
            for (int i = 0; i < Nx; i++)
                f[i] = 0.0;
            for (int ix = Nx / 4; ix < Nx / 2; ix++)
                f[ix] = 1.0;
            for (int ix = Nx / 2; ix < 3 * Nx / 4; ix++)
                f[ix] = -1.0;
            return f;
        }
    }

public static class Preobpazovanie
{
    public static List<Double> Basis_Haara(List<Double> f)
    {
        // Делаем копию f, изменяем и возвращаем.
    }
}
 
 
public static class Pamat
{
    public static List<Double> doubleFromFile(string path)
    {
        //Читаем и возвращаем список
    }
 
    //public static List<Double> Preobr() //Зачем это? Сами обратятся к Preobpazovanie.Basis_Haara()
}

public List<Double> Pruamoe(List<List<double>> S, List<List<double>> D)//спросить, как правильно переделывать данные методы
        {
            // аппроксимирующие коэффициенты
            // детализирующие коэффициенты
 
            //S = new double[M][];
            int Mx = 1;
            for (int m = 0; m < S.Count; m++)
            {
                S[m] = new double[Mx];
                Mx *= 2;
            }
            D = new double[M][];
            Mx = 1;
            for (int m = 0; m < D.Length; m++)
            {
                D[m] = new double[Mx];
                Mx *= 2;
            }
 
            //     // производим вычисление матриц S и D (прямое вейвлет преобразование)
            int N = Nx;
            for (int m = M - 1; m >= 0; m--)
            {
                N = N / 2;
                for (int n = 0; n < N; n++)
                {
                    S[m][n] = (f[2 * n] + f[2 * n + 1]) / 2;
                    D[m][n] = (f[2 * n] - f[2 * n + 1]) / 2;
                    int i = n;
                }
                // перезапишим исходный массив
                for (int n = 0; n < N; n++)
                {
                    f[n] = S[m][n];
                }
            } // конец прямого вейвлет преобразования
            return S;
        }
 
 
        public List<Double> Obratnoe(List<List<double>> S, List<List<double>> D, List<Double> f)
        {
            // осуществим обратное вейвлет преобразование
            // (восстановим исходный сигнал)
            // для этого нам необходимо использовать значение
            // среднего уровня сигнала S[0][0] и
            // значения детализирующих коэффициентов D
            // результат будем записывать в массив S
 
            ;
 
            //Вообще думаю надо в отдельный метод, на обратное, чтобы вызывать их когда нужно и какой нужно, но это потом.
            for (int m = 0; m < M - 1; m++)
            {
                for (int n = 0; n <= m; n++)
                {
                    S[m + 1][2 * n] = (S[m][n] + D[m][n]);
                    S[m + 1][2 * n + 1] = (S[m][n] - D[m][n]);
                    int i = n;
                }
                int k = m;
 
            } // конец вычисления матрицы S для братного вейвлет преобразования
 
            // окончательное восстановление исходного поля
            for (int ix = 0; ix < Nx / 2; ix++)
            {
                f[2 * ix] = S[M - 1][ix] + D[M - 1][ix];
                f[2 * ix + 1] = S[M - 1][ix] - D[M - 1][ix];
                int i = ix;
            }
            for (int ix = 0; ix < Nx; ix++)
            {
                // textBox6.Text += f[ix].ToString() + "\r\n ";
                // printf("%6.3f ", f[ix]);
                //Выдаю на печать первоначальный
 
            }
        }

Ispolsovanie_Algoritmov pm = new Ispolsovanie_Algoritmov();
List<Double> lst3 = new List<Double>();

private void открытьToolStripButton_Click(object sender, EventArgs e)

private void button1_Click_1(object sender, EventArgs e)

List<Double> lst2 = new List<Double>();
Ispolsovanie_Algoritmov ggg = new Ispolsovanie_Algoritmov();

  /// <summary>
        /// Преобразование Хаара
        /// Выполняется указанное количество раз
        /// </summary>
        public void HaarTransform(ref float[] array, int level)
        {
            int SIZE = array.GetLength(0);    // Количество элементов
            float[] avg = new float[SIZE];    // Суммы
            float[] diff = new float[SIZE];   // Разности
 
            // count - количество повторов
            for (int count = SIZE; count > array.Length / (2 * level); count /= 2)
            {
                // Рассчитать полусуммы и разности, занести во временные массивы сумм и разностей
                for (int i = 0; i < count / 2; i++)
                {
                    avg[i] = (array[2 * i] + array[2 * i + 1]) / 2;
                    diff[i] = array[2 * i] - avg[i];
                }
 
                // Перенести суммы и разности в итоговый массив
                for (int i = 0; i < count / 2; i++)
                {
                    array[i] = avg[i]; // В первую половину
                    array[i + count / 2] = diff[i]; // Во вторую половину
                }
            }
        }

 public static List<Double> doubleFromFile(string path)
        {
            System.IO.StreamReader sr = new StreamReader(path);
            var lst1 = new List<Double>();
            
            while (!sr.EndOfStream)
            {
                var str = sr.ReadLine();
                var curDouble = Convert.ToDouble(str);
                lst1.Add(curDouble);
            }
            return lst1;
        }

using System;
using System.Collections.Generic;
 
namespace ConsoleApplication1
{
    class Program
    {
        static void Main()
        {
            var lst = new List<double>();
            lst.Add(-0.008);
            lst.Add(0.01);
            lst.Add(0.9);
            lst.Add(1);
            lst.Add(10);
            lst.Add(100);
            var rnd = new Random();
 
            int oldLstCount = lst.Count;
            for (int lstIndex = 0; lstIndex < oldLstCount; lstIndex++)
            {
                var exp = Math.Floor(Math.Log10(Math.Abs(lst[lstIndex])));
                for (int i = 0; i < 10; i++) //Добавляем 10 случайных шумовых чисел для каждого реального
                {
                    double rndDig = rnd.Next(1, 9) + rnd.NextDouble(); //Случайное число нулевого порядка от 1 до 10 (не включая)
                    double addingVal;
                    addingVal = rndDig * Math.Pow(10, exp); //Делаем ему нужный порядок
                    addingVal *= Math.Sign(lst[lstIndex]); //Делаем знак таким же, как у исходного числа.
                    //bool isPos = (rnd.Next(2) == 1); //Делаем случайным знак числа. 0 - отрицательный, 1 - положительный.
                    //if (!isPos)
                    //    addingVal *= -1;
 
                    lst.Add(addingVal);
                }
            }
        }
    }
}

using System;
using System.Collections.Generic;
using System.Globalization;
using System.IO;
 
namespace ConsoleApplication1
{
    class Program
    {
        static NumberFormatInfo nfi = new NumberFormatInfo();
 
        static void Main()
        {
            nfi.NumberDecimalSeparator = "."; //Может и не обязательные 2 строки эти (у меня они по умолчанию так заданы...)
            nfi.NumberGroupSeparator = ",";
            var lst = doubleFromFile(@"D:\Grapher Project Document111.txt");
            foreach (var dbl in lst)
            {
                Console.WriteLine(dbl);
            }
        }
 
        public static List<Double> doubleFromFile(string path)
        {
            StreamReader sr = new StreamReader(path);
            var lst1 = new List<Double>();
            while (!sr.EndOfStream)
            {
                var str = sr.ReadLine();
                var curDouble = Convert.ToDouble(str, nfi);
                lst1.Add(curDouble);
            }
            return lst1;
        }
    }
}

 public static List<double> HaarTransform(List<double> f)
        {
            var copping = new List<double>(f);
            int M = 3;
            int Nx = copping.Count;
             double[][] S;    // аппроксимирующие коэффициенты
            double[][] D;    // детализирующие коэффициенты
            // int SIZE = array.GetLength(0);    // Количество элементов
            //var Sum = new List<double>(Nx/2);    // Суммы
            //var Diff = new List<double>(Nx/2);   // Разности
                S = new double[M][];
                int Mx = 1;
                for (int m = 0; m < S.Length; m++)
                {
                    S[m] = new double[Mx];
                    Mx *= 2;
                }
                D = new double[M][];
                Mx = 1;
                for (int m = 0; m < D.Length; m++)
                {
                    D[m] = new double[Mx];
                    Mx *= 2;
                }
 
                int N = Nx;
                for (int m = M - 1; m >= 0; m--)
                {
                    N = N / 2;
                    for (int n = 0; n < N; n++)
                    {
                        S[m][n] = (f[2 * n] + f[2 * n + 1]) / 2;
                        D[m][n] = (f[2 * n] - f[2 * n + 1]) / 2;
                        int i = n;
                    }
                    // перезапишим исходный массив
                    for (int n = 0; n < N; n++)
                    f[n] = S[m][n];
 
                }  // конец прямого вейвлет преобразования
                //N = Nx;
                //for (int m = M - 1; m >= 0; m--)
                //{
                //    N = N / 2;
                //    for (int n = 0; n < N; n++)
                //    {
                //        copping[n] = S[m][n];
                //        copping[n + Nx / 2] = D[m][n];
                //    }
                //}
                return f;
            }

 // перезапишим исходный массив
                for (int n = 0; n < N; n++)
                    f[n] = S[m][n];
 
            } // конец прямого вейвлет преобразования
 
            // выдадим результаты на печать
            N = Nx;
            for (int m = M - 1; m >= 0; m--)
            {
                N = N / 2;
                for (int n = 0; n < N; n++)
                {
                    textBox4.Text += S[m][n].ToString() + " \r\n";
                }
             }