以下计算运行速度比R慢得多:
let result = (X.Transpose() * b * X).Inverse() * (X.Transpose() * b) * e // about 4 seconds on my machine
或这个:
let result = (X.Transpose() * b * X).QR().Solve((X.Transpose() * b) * e)
哪里
open MathNet.Numerics.LinearAlgebra
let X = DenseMatrix.init 2000 7 (fun i j -> 1.)
let b = SparseMatrix.ofDiag (vector [for i in 0 .. 1999 do yield 1.])
let e = DenseMatrix.init 2000 1 (fun i j -> 1.)
但是在R中,通过以下方法可以实现相同的计算,只需要几百毫秒:
result <- solve(crossprod(X,b*X), crossprod(X,b*e)) // …玩F#,我试图以更实用的方式思考代码.我工作的很大一部分恰好是数字化的,所以我在想这种再教育是否有意义.是否正在以一种功能性的方式编写数字代码,例如试图在圆孔中安装方形钉,或者它只是一个陡峭的学习曲线而不管应用程序如何？
例如,让我们拿一个片段来演示大数的弱定律:
open System
open System.IO
open System.Windows.Forms
open System.Windows.Forms.DataVisualization
open FSharp.Data
open FSharp.Charting
open FSharp.Core.Operators
open MathNet.Numerics
open MathNet.Numerics.LinearAlgebra
open MathNet.Numerics.Random
open MathNet.Numerics.Distributions
open MathNet.Numerics.Statistics
let T = 1000
let arr1 = Array.init T (fun i -> float i*0.)
for i in 0 .. T-1 do
arr1.[i] <- [|for j in 1..i do yield Exponential.Sample(0.1)|] |> Statistics.Mean
let arr2 = Array.init T (fun i -> float i*0.)
for i in 0 .. T-1 do
arr2.[i] <- arr1.[1 .. i] …当CONFLATE选项设置为true时,ZMQ订户套接字仅保留队列中的最后一条消息.(zmq_docs)然而,它似乎并不适合我.通常在python中我会做类似下面的事情,它会工作:
context = zmq.Context()
subscriber = context.socket(zmq.SUB)
subscriber.setsockopt(zmq.CONFLATE, 1)
subscriber.connect("tcp://localhost:5555")
下面的发布/订阅模式中的订阅者只是忽略设置为1的CONFLATE选项.您可以通过订阅者显示的分钟和秒来观察程序在处理旧消息时被绑定(文档42).如果将fib设置为一个微不足道的值,您可以看到订阅者确实正在接收来自发布者的消息.
这是出版商:
open System
open fszmq
open fszmq.Context
open fszmq.Socket
let funcPublish () =
use context = new Context()
use publisher = pub context
"tcp://*:5563" |> bind publisher
while true do
let tm = System.DateTime.Now
let t = String.Concat([tm.Minute.ToString(); " "; tm.Second.ToString()])
t |> s_send publisher
sleep 1
EXIT_SUCCESS
[<EntryPoint>]
let main argv =
funcPublish ()
0
这是订户:
open fszmq
open fszmq.Context
open fszmq.Socket
let rec fib n …假设在进入长时间运行的进程之前,必须执行一些预启动检查.
还假设一旦满足这些检查,您就不需要再次进行检查(可能有许多检查并且执行起来也相对昂贵).
如何在这里避免国家？
更一般地说,在Python中,你可以使用类似于生成器或协同程序的东西来保存这些检查和状态.是否有一个很好的F-sharpy方法摆脱可变的布尔值,以表明跳过每个满意的检查？
let r = new System.Random()
let someCondition1 () =
r.Next() % 523452321 = 0
let someCondition2 () =
r.Next() % 243142321 = 0
let mutable conditionCheck1 = false
let mutable conditionCheck2 = false
let rec conditionChecks () =
match conditionCheck1 with
| true -> ()
| false -> match someCondition1 () with
| false -> conditionChecks ()
| true -> conditionCheck1 <- true // never check again
match conditionCheck2 with
| true -> ()
| false …在尝试将以下C#代码翻译为F#时,我正在努力使用'using'关键字.以下代码段来自ILNumerics库.如何翻译以下内容？
ILRetArray<double> ObjFuncBFGS2D(ILInArray<double> X) {
using (ILScope.Enter(X)) {
return X[0] * X[0] + X[1] * X[1] + 2;
}
}
另外,F#人们倾向于使用哪些库进行优化？我一直在使用NLoptNet,但是在Matlab,Julia和Python中正确收敛的例程存在非常奇怪的收敛问题.所以问题在于我的F#翻译(更有可能授予)或优化库.这是我希望确定的.坦率地说,我对互联网上缺乏与F#相关的数值优化材料感到有些惊讶.
我正在寻找一种在F#中编程过滤器的惯用方法.为清楚起见,我将过滤器称为一种功能,它随着时间的推移使用一系列测量值并产生不断变化的估计值.这意味着该功能能够维持状态.例如,在Python中,可以使用协同程序以非常干净的方式维护状态.
我正在寻找的是用F#编程过滤器的惯用方法.鉴于我的思想受到OOP和程序原则的彻底污染,我自然而然地想出了表达它们的课程.在F#中有一种更惯用的过滤方法,可能会开启功能范式的其他好处吗？
open System
open MathNet.Numerics.LinearAlgebra
open MathNet.Numerics.Random
open MathNet.Numerics.Distributions
open MathNet.Numerics.Statistics
open FSharp.Charting
type ScalarKalman (A : float, H : float, Q : float, R : float) = class
let mutable A = A
let mutable H = H
let mutable Q = Q
let mutable R = R
let mutable p = 0.
let mutable x = 0.
let mutable k = 0.
let mutable result = 0.
member this.X
with get() = x
and set(value) = x …当repl变量设置为false时,为什么以下函数返回不正确长度的序列？
open MathNet.Numerics.Distributions
open MathNet.Numerics.LinearAlgebra
let sample (data : seq<float>) (size : int) (repl : bool) =
let n = data |> Seq.length
// without replacement
let rec generateIndex idx =
let m = size - Seq.length(idx)
match m > 0 with
| true ->
let newIdx = DiscreteUniform.Samples(0, n-1) |> Seq.take m
let idx = (Seq.append idx newIdx) |> Seq.distinct
generateIndex idx
| false ->
idx
let sample =
match repl with
| true ->
DiscreteUniform.Samples(0, n-1)
|> Seq.take …给定一个字符串，例如
一：1.0|二：2.0|三：3.0
我们如何创建一个字符串形式的字典：float？
open System
open System.Collections.Generic
let ofSeq (src:seq<'a * 'b>) =
// from fssnip
let d = new Dictionary<'a, 'b>()
for (k,v) in src do
d.Add(k,v)
d
let msg = "one:1.0|two:2.0|three:3.0"
let msgseq = msg.Split[|'|'|] |> Array.toSeq |> Seq.map (fun i -> i.Split(':'))
let d = ofSeq msgseq // The type ''a * 'b' does not match the type 'string []'
此操作将在一个紧密循环内进行，因此效率将是一个加分项。虽然我也想看到一个简单的解决方案，只是为了让我的 F# 轴承。
谢谢。
如何在不覆盖现有定义的情况下重载基本运算符(+, - ,*)？阅读关于这个主题的其他一些主题,我无法理解该怎么做.具体来说,我希望直接在Array2D类型上定义矩阵运算.MathNet.Numerics以某种方式设法为其Matrix和Vector类型做到这一点但不确定如何.定义常规函数而不是使用运算符完全满足线性代数繁重应用中的逻辑.
type Array() =
static member (+) (A : float[,], B : float[,]) =
let r = A.GetLength 0
let c = A.GetLength 1
let C = Array2D.create r c 0.
for i in 0..r-1 do
for j in 0..c-1 do
C.[i, j] <- A.[i, j] + B.[i, j]
C
let a1 = Array2D.create 4 4 1.
let a2 = Array2D.create 4 4 1.
let a3 = a1 + a2 // type float[,] does not support the operator …不确定如何填充DenseMatrix类型:
let rows = [|for line in File.ReadAllLines("Z:\\mypath.csv")
|> Seq.skip 1 do yield line.Split(',') |> Array.map float|]
let data = DenseMatrix.ofRowArrays rows
let mutable data_logdiff = DenseMatrix.zero<float> (data.RowCount-1) (data.ColumnCount)
for i in [0 .. data.ColumnCount-1] do
for j in [1 .. data.RowCount-1] do
data_logdiff.At(j-1, i) <- data.At(j, i) / data.At(j-1, i) |> log
最后一行生成错误"无效分配".
还想知道是否有一种功能性的方式来表达上面的逻辑.
谢谢.
在F#中有没有类似 Matlab的horzcat()和vertcat()函数？因为我现在正在做的事情看起来像asinine.这里有一个相关的问题,但似乎过时了.
let arr = Array.init 5 (fun i -> 1.)
let xMat = DenseMatrix.init l 2 (fun r c -> if c = 0 then 1. else arr.[r])
谢谢.
[编辑]有一个Array.concat但它似乎只能垂直工作.
在网上找不到在F#中使用NLopt的例子,我一直试图将NLoptNet上给出的例子从C#转换为F#.对C#不熟悉,对F#不太熟悉,我一直在屠杀它.
这是我到目前为止:
open NLoptNet
open System
let solver = new NLoptSolver(NLoptAlgorithm.LN_COBYLA, uint32(1), 0.001, 100)
solver.SetLowerBounds([|-10.0|])
solver.SetUpperBounds([|100.0|])
let objfunc (variables : float array) =
Math.Pow(variables.[0] - 3.0, 2.0) + 4.0
solver.SetMinObjective(objfunc)
let initial_val = [|2.|]
let finalscore = ref System.Nullable() // ERROR
let result = solver.Optimize(initial_val, finalscore)
以下是错误的描述:
连续的参数应该用空格或元组分隔,涉及函数或方法应用程序的参数应该用括号括起来
更具体地说,我正在尝试将以下三行C#转换为F#:
double? finalScore;
var initialValue = new[] { 2.0 };
var result = solver.Optimize(initialValue, out finalScore);
有任何想法吗？