C#与F#混合编程

本人非计算机专业，职业也不是码农，接触编程工作只是为了处理工作中的重复性工作。

在经历了VBA->Visual Basic .Net->Visual C# WinForm->Visual C# WPF后，经过系统性学历，觉得Visual F#在编写程序的数学运算库是一个比较好的语言，函数式编程确实容易理解。

当然，目前全程使用F#来编写WPF看起来不那么简单，鉴于F#有.Net支持，那么就可以只用F#写库，C#写WPF界面操作与响应。

经过系统性整理后，发现函数式语言确实有其魅力之处，比如我的最小二乘法实例：

c#版本

        public static List<double> LinearFittingByLeastSquares(List<double> xaxis, List<double> yaxis, bool flag)// Least Squares Linear Fitting
        {


            // Var Init
            //double[] result = new double[3];
            List<double> ans = new List<double>();
            double interceptb = 0, slopek = 0, sumx = 0, sumy = 0, sumxy = 0, sumxsq = 0, corrcoef;
            int i, num;
            num = xaxis.Count;

            // Calculate Sums
            for (i = 0; i < num; i++)
            {
                sumx += xaxis[i];
                sumy += yaxis[i];
                sumxy += xaxis[i] * yaxis[i];
                sumxsq += xaxis[i] * xaxis[i];
            }

            sumx = sumx / num;
            sumy = sumy / num;

            // Calculate Intercept & Slope
            slopek = (sumxy - num * xaxis.Average() * yaxis.Average()) / (sumxsq - num * Pow(xaxis.Average(), 2));
            interceptb = sumy - slopek * sumx;

            // Output
            //result[0] = slopek;
            //result[1] = interceptb;
            ans.Add(slopek);
            ans.Add(interceptb);

            double avgx = xaxis.Average(), avgy = yaxis.Average(),
                    upper = 0, lowerx = 0, lowery = 0;
            for (i = 0; i < num; i++)
            {

                upper += (xaxis[i] - avgx) * (yaxis[i] - avgy);
                lowerx += Pow(xaxis[i] - avgx, 2);
                lowery += Pow(yaxis[i] - avgy, 2);

            }
            corrcoef = upper / Pow(lowerx * lowery, 0.5);
            //result[2] = corrcoef;
            ans.Add(corrcoef);
            return ans;

        }

F#版本

let LeastSquareMethod (samples:(float*float) list)=
        match samples with
        |[]|[_]->failwith "ItemNumber Error"
        |_->let count=float samples.Length
            let sumx=samples|>List.sumBy (fun (x,y)->x)
            let sumy=samples|>List.sumBy (fun (x,y)->y)
            let sumxy=samples|>List.sumBy (fun (x,y)->x*y)
            let sumx2=samples|>List.sumBy (fun (x,y)->x|>square)
            let dishu=(count*sumx2-square sumx)
            match dishu with
            |0.->failwith "Items All the same"
            |_->let k=(count*sumxy-sumx*sumy)/dishu
                let b=(sumy-k*sumx)/count
                let corrcoef=samples|>List.map (fun (x,y)->(y-k*x-b)|>square)|>List.sum|>sqrt
                {K=k;b=b;Corrcoef=corrcoef}

有没有觉得F#简介明了一些

转载于:https://my.oschina.net/u/3043607/blog/787848