小编Old*_*vec的帖子

安装VS11后,我开始收到以下错误:

考虑从版本"2.0.0.0"[C:\ Program Files(x86)\ Reference Assemblies\Microsoft\FSharp\2.0\Runtime\v2中重新装配程序集"FSharp.Core,Culture = neutral,PublicKeyToken = b03f5f7f11d50a3a"的app.config. 0\FSharp.Core.dll]到版本"4.0.0.0"[C:\ Program Files(x86)\ Reference Assemblies\Microsoft\FSharp\2.0\Runtime\v4.0\FSharp.Core.dll]来解决冲突和摆脱警告.C:\ Windows\Microsoft.NET\Framework\v4.0.30319\Microsoft.Common.targets(1490,5):警告MSB3247:发现同一依赖程序集的不同版本之间存在冲突.

我该怎么办？我不知道如何做这样的重新映射.

请考虑以下代码:

type Test () =
  member o.fn1 (?bo) = 1
  member o.fn2 (?bo) = o.fn1 bo

  member o.fn3 (?bo) = 1 + bo.Value
  member o.fn4 (?bo) = o.fn3 bo

虽然fn1和fn2工作就好了,fn4产生以下错误:

init.fsx(6,30):错误FS0001:这个表达式应该是int类型,但是这里有类型'a option

MSDN声明:

可选参数被解释为F#选项类型,因此您可以通过使用具有Some和None的匹配表达式以常规方式查询它们以查询选项类型.

对我来说,可选参数不会被解释为F#选项类型,否则代码将被编译.此外,我不明白为什么,当我?bo在fn3工具提示中盘旋时,val bo: int option但只是从外面预期int.我期望一个接受任何东西的行为,int,Some int和None.而作为最后一点,我不明白为什么fn2有效,但却fn4没有.

谢谢你的澄清

假设我有以下代码:

let a = ref 4.

printfn "1) a = %g" !a

let t1 = System.Threading.Thread (fun () ->
  lock a (fun () ->
    printfn "locked"
    System.Threading.Thread.Sleep 1000
    printfn "unlocked") )
t1.Start()

System.Threading.Thread.Sleep 100

a := 8.
printfn "2) a = %g" !a

这给出了以下结果:

1)a = 4
锁定
2)a = 8

val a:float ref = {contents = 8.0;}
val t1:System.Threading.Thread

解锁

当我锁定它时为什么a等于8.？是否可以使用可变值和refs锁定记录？

PS:我需要锁定一个对象,这个对象既可以由我访问,也可以由WCF同时访问.

以下代码导致slow1 = 1323 ms,slow2 = 1311 ms和fast = 897 ms.怎么可能？

这里:嵌套或不嵌套的if-blocks？他们提到这一点

任何现代编译器,我的意思是在过去20年中构建的任何东西,都会将这些编译器编译成相同的代码.

let s = System.Diagnostics.Stopwatch()
let mutable a = 1
s.Start()

for i in 0 .. 1000000000 do
  if i < 0 then
    if i < 0 then
      a <- 4

printfn "fast = %d" s.ElapsedMilliseconds

s.Restart()

for i in 0 .. 1000000000 do
  if i < 0 && i < 0 then
    a <- 4

printfn "slow1 = %d" s.ElapsedMilliseconds …

为什么每次通话都要评估tb？有没有什么方法可以让它只评估一次？

type test =
  { a: float }
  member x.b =
    printfn "oh no"
    x.a * 2.

let t = { a = 1. }
t.b
t.b

我使用F#开发了Lattice Boltzmann(流体动力学)代码.我现在正在24核128 GB内存服务器上测试代码.代码基本上由一个用于时间演化的主递归函数和一个用于三维空间迭代的System.Threading.Tasks.Parallel.For循环内部组成.3D空间是500x500x500大,一个时间周期需要:).

let rec timeIterate time =
  // Time consuming for loop
  System.Threading.Tasks.Parallel.For(...)

我希望服务器使用所有24个核心,即100%的使用率.我观察到的是1%-30%的使用率.

我的问题是:

1. F#是否适合在此类服务器上进行HPC计算？
2. 对于现实世界的问题,使用高达100%的CPU是否现实？
3. 我该怎么做才能获得高速度？一切都在一个大的并行循环中,所以我希望这就是我应该做的......
4. 如果F#不是一种合适的语言,那么什么语言？

谢谢你的任何建议.

编辑:我愿意分享代码,如果有人有兴趣看看它.

EDIT2:这是代码的剥离版本:http://dl.dropbox.com/u/4571/LBM.zip 它没有做任何合理的事情,我希望我没有通过剥离代码引入任何错误:)

启动文件是ShearFlow.fs,文件底部是

let rec mainLoop (fA: FArrayO) (mR: MacroResult) time =
  let a = LBM.Lbm.lbm lt pA getViscosity force g (fA, mR)

为什么这段代码不起作用？

type Test() =
  static member func (a: seq<'a seq>) = 5.

let a = [[4.]]
Test.func(a)

它给出以下错误:

The type 'float list list' is not compatible with the type 'seq<seq<'a>>'

如何获得关于我的F#代码的一些很好的统计数据？

我可以想象像

• 我的代码行数
• 文件数量
• 字符数？
• 功能,类,模块等的数量

我是图像分析的新手.你知道如何以这种方式将这种图像二值化以获得光纤吗？

我尝试了不同的门限技术等,但我没有成功.我不介意我应该使用什么工具,但我更喜欢.NET或Matlab.

PS:我不知道在哪里提出答案,所以我把它放在StackOverflow上.

我有一个在Windows Server 2008 SE和64个处理器上运行的多进程.NET(F#)科学模拟.模拟的每个时间步长从1.5秒振荡到2秒.由于每个进程必须等待其他进程,因此总速度是最慢进程的速度(2秒*迭代次数).因此,我需要尽可能地减少过程的振荡.

有没有办法如何强制一组进程为他们的计算提供完全相同的"计算时间"？