public cFeedBackMessage Run()
        {
            ToReturn = new cExtendedTable(this.Widht,this.Height,0);

            RND = new Random(this.Seed);

            if (this.DistributionType == eRandDistributionType.UNIFORM)
            {

                foreach (cExtendedList item in ToReturn)
                    for (int i = 0; i < item.Count; i++)
                        item[i] = RND.NextDouble() * (Max - Min) + Min;
            }
            else if (this.DistributionType == eRandDistributionType.GAUSSIAN)
            {
                foreach (cExtendedList item in ToReturn)
                    for (int i = 0; i < item.Count; i++)
                    {
                        double u1 = RND.NextDouble();
                        double u2 = RND.NextDouble();
                        double randStdNormal = Math.Sqrt(-2.0 * Math.Log(u1)) * Math.Sin(2.0 * Math.PI * u2);
                        item[i] = this.Mean + this.Stdev * randStdNormal;
                    }
            }
            else
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "Distribution Type not implemented";
            }

            return FeedBackMessage;
        }

        public cFeedBackMessage Run()
        {
            base.Start();

            // Here is the right way for accessing the parameters...
            // a little laborious, but that's the price to pay for a complete interface
            object _firstValue = base.ListProperties.FindByName("First Paramater");
            double firstValue = 0;
            if (_firstValue == null)
            {
                base.GenerateError("First Paramater not found !");
                return base.FeedBackMessage;
            }
            try
            {
                cProperty TmpProp = (cProperty)_firstValue;
                firstValue = (double)TmpProp.GetValue();
            }
            catch (Exception)
            {
                base.GenerateError("First Paramater cast didn't work");
                return base.FeedBackMessage;
            }

            ToReturn = new cExtendedTable((int)firstValue, (int)firstValue, 0);

            base.End();
            return FeedBackMessage;
        }

        public cFeedBackMessage Run()
        {
            if (this.Input == null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input data defined.";
                return FeedBackMessage;
            }

            this.OutPut = new cExtendedTable(this.Input);
            cRandomGenerator RG = new cRandomGenerator(this.Input.Count, this.Input[0].Count);
            RG.Seed = (int)System.DateTime.Now.Ticks;
            RG.Min = this.Min;
            RG.Max = this.Max;
            RG.Mean = this.Mean;
            RG.Stdev = this.Stdv;
            RG.DistributionType = this.DistributionType;

            FeedBackMessage = RG.Run();
            if (FeedBackMessage.IsSucceed == false)
            {
                return FeedBackMessage;
            }

            cArithmetic_DualOperator DO = new cArithmetic_DualOperator();
            DO.SetInputData(this.Input, RG.GetOutPut());
            DO.OperationType = eBinaryOperationType.ADD;
            DO.Run();

            this.OutPut = DO.GetOutPut();
            this.OutPut.Name = "Add Noise(" + this.Input.Name + ")";

            return FeedBackMessage;
        }

        public cFeedBackMessage Run()
        {
            if(this.Input==null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input data";
            }

            this.OutPut = new cExtendedTable(this.Input);
            this.OutPut[0].Name = "X";
            this.OutPut.Add(new cExtendedList());
            this.OutPut[1].Name = "Sigmoid(X)";

            foreach (var item in this.Input)
            {
                //double Value = Bottom +
                //    ( (Top - Bottom) / (1 + Math.Pow(10, (Math.Log10(EC50) - item) * Slope) ) );

                double Value = Bottom + (Top - Bottom) / (1 + Math.Pow((EC50 / item),Slope));

                this.OutPut[1].Add(Value);
                        /// (1 + Math.Pow((Math.Pow(10, EC50) / Math.Pow(10, /*ResultFit.GetLogConcentrations()*/item)), Slope)));
            }

            //for (int IdxConc = 0; IdxConc < this.Input[0].Count; IdxConc++)
            // {
            //    Y_Estimated.Add(c[0] + (c[1] - c[0]) / (1 + Math.Pow((Math.Pow(10, c[2]) / Math.Pow(10, /*ResultFit.GetLogConcentrations()*/this.Input[0][IdxConc])), c[3])));
            //    //   ResultFit.Y_Estimated.Add(c[0] + (c[1] - c[0]) / (1 + Math.Pow(((c[2]) /  ResultFit.GetLogConcentrations()[IdxConc]), c[3])));
            // }

            return FeedBackMessage;
        }

        public cFeedBackMessage Run()
        {
            this.Output = new cExtendedTable();
            this.Output.Tag = this.ListObjects.Tag;
            this.Output.Name = "3D View Associated Data Table";
                if(this.ListObjects.Name!=null)
                    this.Output.Name += this.ListObjects.Name;
            this.Output.ListTags = new List<object>();
            this.Output.ListRowNames = new List<string>();

            this.Output.Add(new cExtendedList("X"));
            this.Output.Add(new cExtendedList("Y"));
            this.Output.Add(new cExtendedList("Z"));

            foreach (var item in this.ListObjects)
            {
                this.Output[0].Add(item.GetPosition().X);
                this.Output[1].Add(item.GetPosition().Y);
                this.Output[2].Add(item.GetPosition().Z);
                this.Output.ListTags.Add(item.Tag);
                this.Output.ListRowNames.Add(item.GetName());
            }

            return FeedBackMessage;
        }

        private cFeedBackMessage Process()
        {
            this.Output = new cExtendedTable(this.Input);

            //int IDxCOl = 0;
               // foreach (cExtendedList item in this.Output)
            for (int IDxCOl = 0; IDxCOl < this.Output.Count; IDxCOl++)
            {
                this.Output[IDxCOl] = Input[IDxCOl].Normalize(this.NormalizationType);
            }

            switch (this.NormalizationType)
            {
                case eNormalizationType.STANDARDIZE :
                    this.Output.Name = "Standardize(" + this.Input.Name + ")";
                    break;
                case eNormalizationType.MIN_MAX:
                    this.Output.Name = "MinMax(" + this.Input.Name + ")";
                    break;
                case eNormalizationType.SHIFT_TO_MEAN:
                    this.Output.Name = "Shift To Mean(" + this.Input.Name + ")";
                    break;
                case eNormalizationType.SHIFT_TO_MEDIAN:
                    this.Output.Name = "Shift To Median(" + this.Input.Name + ")";
                    break;
                case eNormalizationType.SHIFT_TO_MIN:
                    this.Output.Name = "Shift To Min(" + this.Input.Name + ")";
                    break;
                default:
                    break;
            }

            return base.FeedBackMessage;
        }

        public cFeedBackMessage Run()
        {
            if (this.Input == null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input data defined.";
                return FeedBackMessage;
            }

            OutPutList = new cExtendedList();
            OutPutList.ListTags = new List<object>();
            for (int i = 0; i < this.Input.Count; i++)
            {
                for (int j = 0; j < this.Input[0].Count; j++)
                {
                    OutPutList.Add(this.Input[i][j]);
                }
                if (this.Input[i].ListTags != null)
                {

                    for (int j = 0; j < this.Input[i].Count; j++)
                        OutPutList.ListTags.Add(this.Input[i].ListTags[j]);
                }
            }

            this.OutPut = new cExtendedTable(OutPutList);
            this.OutPut.Name = "Linearize(" + this.Input.Name + ")";

            return FeedBackMessage;
        }

        private void Process()
        {
            this.OutPut = new cExtendedTable();
            double Value = double.NaN;
            this.OutPut.ListRowNames = new List<string>();

            this.OutPut.Name = "Z-Factor(s)";

            for (int IdxCol = 0; IdxCol < this.Input.Count; IdxCol++)
            {
                this.OutPut.ListRowNames.Add(this.Input[IdxCol].Name);
                cExtendedList NewResult = new cExtendedList();
                NewResult.Name = this.Input[IdxCol].Name;
                for (int IdxColBis = 0; IdxColBis < this.Input.Count; IdxColBis++)
                {
                    if (IdxCol != IdxColBis)
                        Value = this.Input[IdxCol].ZFactor(this.Input[IdxColBis], this.IsRobust);
                    else
                        Value = double.NaN;

                    //if (double.IsInfinity(Value)) Value = 1;

                    NewResult.Add(Value);
                }
                this.OutPut.Add(NewResult);
            }

            base.Info = "Z-Factor (";
            if (IsRobust) base.Info +=  "Robust) - ";
            else
                base.Info += "Regular) - ";

            base.Info += this.Input[0].Count + " vs. " + this.Input[1].Count + " values.";
        }

        public cFeedBackMessage Run()
        {
            if(this.Input == null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input data defined.";
                return FeedBackMessage;
            }

            OutPut = new cExtendedTable(this.Input);
            this.OutPut.ListRowNames = null;

            int NumberOfColumnsRemoved = 0;
            int RealIdx = 0;
            for (int i = 0; i < this.Input.Count; i++)
            {
                if ((this.Input[i].Count <= this.MinNumberOfData) || (this.Input[i].Count >= this.MaxNumberOfData))
                {
                    this.OutPut.RemoveAt(RealIdx);
                    NumberOfColumnsRemoved++;
                    RealIdx--;
                }
                RealIdx++;
            }

            this.OutPut.Name = "Clean(" + this.Input.Name + ")";

            FeedBackMessage.Message = NumberOfColumnsRemoved + " columns removed";
            return FeedBackMessage;
        }

        public cFeedBackMessage Run()
        {
            if (this.Input == null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input data defined.";
                return FeedBackMessage;
            }
            // ------------- now proceed -------------

            this.OutPut = new cExtendedTable();
            this.OutPut.ListRowNames = new List<string>();

            this.OutPut.Name = "Student's t-Test";

            if (FTestTails == eFTestTails.BOTH)
                this.OutPut.Name += " (both tails)";
            else if (FTestTails == eFTestTails.LEFT)
                this.OutPut.Name += " (left tail)";
            else if (FTestTails == eFTestTails.RIGHT)
                this.OutPut.Name += " (right tail)";

            for (int IdxCol = 0; IdxCol < this.Input.Count; IdxCol++)
            {
                this.OutPut.ListRowNames.Add(this.Input[IdxCol].Name);
                cExtendedList NewResult = new cExtendedList();
                NewResult.Name = this.Input[IdxCol].Name;
                for (int IdxColBis = 0; IdxColBis < this.Input.Count; IdxColBis++)
                {
                    double bothtails;
                    double lefttail;
                    double righttail;

                    if(this.IsUnequalVariance)
                        alglib.unequalvariancettest(this.Input[IdxCol].ToArray(), this.Input[IdxCol].Count, this.Input[IdxColBis].ToArray(), this.Input[IdxColBis].Count, out bothtails, out lefttail, out righttail);
                    else
                        alglib.studentttest2(this.Input[IdxCol].ToArray(), this.Input[IdxCol].Count, this.Input[IdxColBis].ToArray(), this.Input[IdxColBis].Count, out bothtails, out lefttail, out righttail);

                    //alglib.mannwhitneyutest(

                    if (FTestTails == eFTestTails.BOTH)
                        NewResult.Add(bothtails);
                    else if (FTestTails == eFTestTails.LEFT)
                        NewResult.Add(lefttail);
                    else if (FTestTails == eFTestTails.RIGHT)
                        NewResult.Add(righttail);

                }
                this.OutPut.Add(NewResult);
            }

               return FeedBackMessage;
        }

        public cFeedBackMessage Run()
        {
            if (this.Input == null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input defined.";
                return FeedBackMessage;
            }

            if (this.ColumnIndexForSorting >= this.Input.Count)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "Sorting column index exceed table size.";
                return FeedBackMessage;
            }
            Process();

            this.Output = new cExtendedTable(this.Input);
            this.Output.Name = "Sorted "+this.Input.Name;

            int IdxCol = 0;
            foreach (var item in this.Input)
            {
                this.Output[IdxCol].Tag = item.Tag;
                IdxCol++;
            }

            for (IdxCol = 0; IdxCol < this.Input.Count; IdxCol++)
            {
                for (int IdxRow = 0; IdxRow < RefList.Count; IdxRow++)
                    this.Output[IdxCol][IdxRow] = this.Input[IdxCol][RefList[IdxRow].Index];

                if ((this.Input[IdxCol].ListTags != null) && (this.Input[IdxCol].ListTags.Count>0))
                {
                    for (int IdxRow = 0; IdxRow < RefList.Count; IdxRow++)
                        this.Output[IdxCol].ListTags[IdxRow] = this.Input[IdxCol].ListTags[RefList[IdxRow].Index];
                }
            }

            for (int IdxRow = 0; IdxRow < this.Input.ListRowNames.Count; IdxRow++)
                this.Output.ListRowNames[IdxRow] = this.Input.ListRowNames[RefList[IdxRow].Index];

            if (this.Input.ListTags != null)
            {
                for (int IdxRow = 0; IdxRow < this.Input.ListTags.Count; IdxRow++)
                    this.Output.ListTags[IdxRow] = this.Input.ListTags[RefList[IdxRow].Index];
            }

            return FeedBackMessage;
        }

        private void Project()
        {
            Matrix NewPt = new Matrix(this.DataToProject[0].Count, this.DataToProject.Count);
            NewPt = DataToProject.CopyToWEKAMatrix().multiply(this.Basis.CopyToWEKAMatrix());
            ProjectedData = new cExtendedTable(NewPt);

            int Idx=0;
            foreach (var item in DataToProject)
            {
                ProjectedData[Idx].Name = Basis.ListRowNames[Idx];
                Idx++;
            }

            ProjectedData.ListRowNames.AddRange(DataToProject.ListRowNames);
        }

        public cFeedBackMessage Run()
        {
            if (this.Input == null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input data defined.";
                return FeedBackMessage;
            }

            //if (Info != 1)
            //{
            //    FeedBackMessage.IsSucceed = false;
            //    FeedBackMessage.Message = "Error while inversing the matrix";
            //    return FeedBackMessage;
            //}

            this.OutPut = new cExtendedTable(this.Input[0].Count, this.Input.Count, 0);

            if (Input[0].ListTags != null)
            {
                foreach (var item in this.OutPut)
                {
                    item.ListTags = new List<object>();
                }
            }

            this.OutPut.ListRowNames = new List<string>();

            for (int i = 0; i < this.Input.Count; i++)
            {
                this.OutPut.ListRowNames.Add(this.Input[i].Name);
                for (int j = 0; j < this.Input[i].Count; j++)
                {
                    this.OutPut[j][i] = this.Input[i][j];
                    if (this.Input[i].ListTags != null) this.OutPut[j].ListTags.Add(this.Input[i].ListTags[j]);
                }
            }

            if (this.Input.ListRowNames != null)
            {
                for (int i = 0; i < this.Input.ListRowNames.Count; i++)
                    this.OutPut[i].Name = this.Input.ListRowNames[i];
            }

            this.OutPut.Name = "Transpose(" + this.Input.Name + ")";

            return FeedBackMessage;
        }

        public cExtendedTable GetPropertyTable()
        {
            cExtendedTable ToReturn = new cExtendedTable();
            ToReturn.Name = this.Name + " - Properties";

            cExtendedList Properties = new cExtendedList("Properties");

            ToReturn.Add(Properties);
            ToReturn.ListRowNames = new List<string>();


            ToReturn.ListRowNames.Add("Dimension X");
            Properties.Add(this.Width);
            ToReturn.ListRowNames.Add("Dimension Y");
            Properties.Add(this.Height);
            ToReturn.ListRowNames.Add("Dimension Z");
            Properties.Add(this.Depth);

            ToReturn.ListRowNames.Add("Voxel Size X");
            Properties.Add(this.Resolution.X);
            ToReturn.ListRowNames.Add("Voxel Size Y");
            Properties.Add(this.Resolution.Y);
            ToReturn.ListRowNames.Add("Voxel Size Z");
            Properties.Add(this.Resolution.Z);

            ToReturn.ListRowNames.Add("Position X");
            Properties.Add(this.Position.X);
            ToReturn.ListRowNames.Add("Position Y");
            Properties.Add(this.Position.Y);
            ToReturn.ListRowNames.Add("Position Z");
            Properties.Add(this.Position.Z);


            ToReturn.ListRowNames.Add("Channel Numbers");
            Properties.Add(this.GetNumChannels());

            for (int i = 0; i < this.GetNumChannels(); i++)
            {
                ToReturn.ListRowNames.Add(this.SingleChannelImage[i].Name + " - Wavelenght");
                Properties.Add(i);
            }



            return ToReturn;

        }

        public cFeedBackMessage Run()
        {
            if (this.Input == null)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "No input data defined.";
                return FeedBackMessage;
            }
            if (this.Input.Count != this.Input[0].Count)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "A square matrix is required for this operation";
                return FeedBackMessage;
            }

            // ------------- now proceed -------------
            int Info;

            double[,] Mat = this.Input.CopyToArray();
            alglib.rmatrixinverse(ref Mat, out Info, out Report);

            if (Info != 1)
            {
                FeedBackMessage.IsSucceed = false;
                FeedBackMessage.Message = "Error while inversing the matrix";
                return FeedBackMessage;
            }

            this.OutPut = new cExtendedTable(Mat);

            if (this.Input.ListRowNames != null)
            {
                this.OutPut.ListRowNames = new List<string>();
                this.OutPut.ListRowNames.AddRange(this.Input.ListRowNames.ToArray());
            }

            int IdxCOl=0;
            foreach (var item in this.Input)
            {
                this.OutPut[IdxCOl++].Name = item.Name;
            }

            this.OutPut.Name = "Inverse(" + this.Input.Name + ")";

            return FeedBackMessage;
        }

        private cFeedBackMessage Process()
        {
            cExtendedTable TmpTable = new cExtendedTable(this.Input[this.IdxColumnToProcess]);

            cSort S = new cSort();
            S.SetInputData(TmpTable);
            base.FeedBackMessage = S.Run();
            if (base.FeedBackMessage.IsSucceed == false) return base.FeedBackMessage;

            cNormalize N = new cNormalize();
            N.NormalizationType = eNormalizationType.STANDARDIZE;
            N.SetInputData(S.GetOutPut());
            base.FeedBackMessage = N.Run();
            if (base.FeedBackMessage.IsSucceed == false) return base.FeedBackMessage;

            int Num = N.GetOutPut()[0].Count;
            double[] CumulativeProba = new double[Num];
            for (int i = 1; i < Num - 1; i++)
                CumulativeProba[i] = (i - 0.3175) / (Num + 0.365);

            CumulativeProba[Num - 1] = Math.Pow(0.5, 1.0 / Num);
            CumulativeProba[0] = 1 - CumulativeProba[Num - 1];

            double[] PercentPointFunction = new double[Num];

            for (int i = 0; i < Num; i++)
                PercentPointFunction[i] = alglib.normaldistr.invnormaldistribution(CumulativeProba[i]);

            this.Output = new cExtendedTable(new cExtendedList(PercentPointFunction));

            this.Output.Add(new cExtendedList());

            this.Output.ListTags = new List<object>();

            for (int i = 0; i < N.GetOutPut()[0].Count; i++)
            {
                this.Output[1].Add(N.GetOutPut()[0][i]);
                if(S.GetOutPut()[0].ListTags!=null)
                this.Output.ListTags.Add(S.GetOutPut()[0].ListTags[i]);
            }

            this.Output[0].Name = "";
            this.Output[1].Name = "Normalized Data";

            return base.FeedBackMessage;
        }

        cFeedBackMessage Process()
        {
            this.Output = new cExtendedTable();
            this.Output.Name = "Histogram (" + this.Input.Name + ")";

            List<double[]> Res = null;

            if (IsBinNumberMode)
            {
                if (double.IsNaN(this.Min) || double.IsNaN(this.Max))
                    Res = Input[0].CreateHistogram(this.BinNumber, this.IsNormalized);
                else
                    Res = Input[0].CreateHistogram(this.Min, this.Max, (int)this.BinNumber, this.IsNormalized);
            }
            else
            {
                //if (double.IsNaN(this.Min) || double.IsNaN(this.Max))
                //    Res = Input[0].CreateHistogram(this.BinNumber, this.IsNormalized);
                //else
                    Res = Input[0].CreateHistogram(this.Min, this.Max, this.BinSize);
            }

            if (Res.Count == 0)
            {
                base.FeedBackMessage.IsSucceed = false;
                base.FeedBackMessage.Message = "Histogram failure";
                return base.FeedBackMessage;
            }

            string ColName = "Frequency";
            if (IsNormalized) ColName = "Normalized " + ColName;

            cExtendedList ListY = new cExtendedList(ColName);
            if (this.Input[0].Name == "") ColName = "Value";
            else
                ColName = this.Input[0].Name;
            cExtendedList ListX = new cExtendedList(ColName);

            ListX.AddRange(Res[0]);
            ListY.AddRange(Res[1]);

            this.Output.Add(ListX);
            this.Output.Add(ListY);

            return base.FeedBackMessage;
        }

        private void Process()
        {
            this.OutPut = new cExtendedTable();
            double Value = double.NaN;
            this.OutPut.ListRowNames = new List<string>();

                this.OutPut.Name = "Covariance Matrix";
                for (int IdxCol = 0; IdxCol < this.Input.Count; IdxCol++)
                {
                    this.OutPut.ListRowNames.Add(this.Input[IdxCol].Name);
                    cExtendedList NewResult = new cExtendedList();
                    NewResult.Name = this.Input[IdxCol].Name;
                    for (int IdxColBis = 0; IdxColBis < this.Input.Count; IdxColBis++)
                    {
                        Value = alglib.cov2(this.Input[IdxCol].ToArray(), this.Input[IdxColBis].ToArray());
                        NewResult.Add(Value);
                    }
                    this.OutPut.Add(NewResult);
                }
        }

        private void Process()
        {
            this.OutPut = new cExtendedTable();
            double Value = double.NaN;
            this.OutPut.ListRowNames = new List<string>();

            this.OutPut.Name = "Mahalanobis";
            for (int IdxCol = 0; IdxCol < this.Input.Count; IdxCol++)
            {
                this.OutPut.ListRowNames.Add(this.Input[IdxCol].Name);
                cExtendedList NewResult = new cExtendedList();
                NewResult.Name = this.Input[IdxCol].Name;
                for (int IdxColBis = 0; IdxColBis < this.Input.Count; IdxColBis++)
                {
                    Value = this.Input[IdxCol].Dist_Euclidean(this.Input[IdxColBis]);
                    NewResult.Add(Value);
                }
                this.OutPut.Add(NewResult);
            }
        }

        public cExtendedTable GetLiveListValues()
        {
            cExtendedTable CET = new cExtendedTable();
            CET.Name = Input.Name;
            //foreach (DataGridViewColumn item in GridView.SelectedColumns)

            for (int ColumnSelected = 0; ColumnSelected < GridView.SelectedColumns.Count; ColumnSelected++)
            {
                CET.Add(new cExtendedList());
                for (int i = 0; i < GridView.Rows.Count - 1; i++)
                {
                    CET[ColumnSelected].Add(double.Parse(GridView[GridView.SelectedColumns[ColumnSelected].Index, i].Value.ToString()));

                }
                //GridView[item.Index,
                //CET.Add();
            }
            //GridView.SelectedColumns
            return CET;
        }