这适用于F#4.0:
type Something<'a, 'b when 'b :> seq<'b>>() =
这不是:
type Something<'b when 'b :> seq<'b>, 'a>() =
类型名称中的意外符号','.预期的">"或其他令牌.
类型约束的顺序重要的是什么？
我有以下功能
let private sigmoid (z:float) =
1.0 / (1.0 + exp(-z))
let private sigmoidM (z : Matrix<float>) : Matrix<float> =
z.Map (fun x -> sigmoid(x))
let private sigmoidV (z:Vector<float>) =
z.Map(fun x -> sigmoid(x))
我想只有sigmoid并根据输入执行标量,向量或矩阵.
也就是说,这个函数需要非常高效,因为它在循环的最关键部分.有关如何做到这一点的任何见解？如果它很慢,请随意发布如何缓慢.
我正在尝试使用递归定义来实现Hofstadter的Q序列：
Q(1) = 1
Q(2) = 1
Q(n) = Q(n - Q(n-2)) + Q(n - Q(n-1)) for n > 2
我得到的错误结果n > 3。这是我到目前为止的内容：
: Q recursive
dup 3 <
if
drop 1
else
dup dup 2dup 2 - Q - Q -rot 1- Q - Q +
then ;
在线尝试： http : //ideone.com/PmnJRO（编辑：现在具有固定，正确的实现）
我认为这是行不通的，因为每次调用Qwhere n大于之后，都会向堆栈中添加值2，从而使-rot行不通。
是否有一个简单的调整即可完成这项工作？还是我需要使用其他方法，也许将变量用于n？
OEIS：A005185
我有一个代码,用于计算Motzkin数字:
module Main where
-- Program execution begins here
main :: IO ()
main = interact (unlines . (map show) . map wave . (map read) . words)
-- Compute Motzkin number
wave :: Integer -> Integer
wave 0 = 1
wave 1 = 1
wave n = ((3 * n - 3) * wave (n - 2) + (2 * n + 1) * wave (n - 1)) `div` (n + 2)
但即使是简单数字的输出也30需要一段时间才能返回.
任何优化的想法？
type TotalSizeToken = TotalSizeToken with
static member TotalSize(_: TotalSizeToken, (a,b,c,d,e)): int = a*b*c*d*e
static member TotalSize(_: TotalSizeToken, (a,b,c,d)): int = a*b*c*d
static member TotalSize(_: TotalSizeToken, (a,b,c)): int = a*b*c
static member TotalSize(_: TotalSizeToken, (a,b)): int = a*b
static member TotalSize(_: TotalSizeToken, x: int): int = x
let inline size_to_total_size x =
((^s) : (static member TotalSize: TotalSizeToken * ^s -> int) TotalSizeToken, x)
let t = size_to_total_size (1,5) // Error: Expecting a type supporting the operator TotalSize, but given a …我正在做家庭作业,问题是我们得到两个相同大小的int列表,然后将这些数字加在一起.示例如下.
vecadd [1;2;3] [4;5;6];; would return [5;7;9]
我是新手,我需要保持我的代码非常简单,以便我可以从中学习.到目前为止我有这个.(不工作)
let rec vecadd L K =
if L <> [] then vecadd ((L.Head+K.Head)::L) K else [];;
我本质上想要用添加的数字替换第一个列表(L).此外,我尝试使用匹配案例以不同的方式对其进行编码.
let rec vecadd L K =
match L with
|[]->[]
|h::[]-> L
|h::t -> vecadd ((h+K.Head)::[]) K
他们都没有工作,我希望得到任何帮助.
如果我有一个有多个值共享一个孩子的歧视联盟(Apple并且MoreApples都有类型Apple)......
type Apples =
| GrannySmith
| Gala
type Fruit =
| Apple of Apples
| MoreApples of Apples
| Banana
let speakFruit = function
| Apple GrannySmith
| MoreApples GrannySmith -> "granny smith"
| Apple Gala
| MoreApples Gala -> "gala"
| Banana -> "banana"
有没有办法匹配子联合以删除重复？- 就像是:
let speakFruit2 = function
| _ GrannySmith -> "granny smith"
| _ Gala -> "gala"
| Banana -> "banana"
下面的代码试图在F#中进行递归冒泡排序,我收到了错误
"This expression was expected to have type 'unit' but here has type ''a []'"
对于中间三行:
let swap i j (arr : 'a []) =
let tmp = arr.[i]
arr.[i] <- arr.[j]
arr.[j] <- tmp
let rec recursiveBubbleSort i j (sequence : 'a []) =
if i = sequence.Length then sequence //error
elif j = sequence.Length then recursiveBubbleSort (i+1) 0 sequence //error
elif sequence.[i] > sequence.[j] then swap i j sequence //error
recursiveBubbleSort i (j+1) sequence
这真让我感到困惑,因为我发现的所有资源都没有充分解释或暗示为什么会发生这种情况.任何帮助都会有很大的帮助.
我在F# Design PatternsGene Belitski 的优秀书中找到了这段代码:
let (| `` I'm active pattern `` |) x = x + 2
let (`` I'm active pattern `` y) = 40
(*
val ( |`` I'm active pattern ``| ) : x:int -> int
val y : int = 42
*)
作者认识到这是
"如果你记得一个值的let绑定是基于模式匹配的数据反汇编的角落情况,那么一个稍微令人难以置信的例子变得清晰,因此I'm active pattern应用于输入参数40并将结果42绑定到x."
我不明白.为什么I'm active pattern40适用于40,因为40在右侧？我直觉地猜测y = 38,而不是42,将表达式let (`` I'm active pattern `` y) = 40视为隐式函数.
谁能解释一下？
考虑以下 Prolog 程序。
a(X) :- b(_), c(X).
b(1).
b(2).
b(3).
c(1).
运行查询：
a(X).
在 SWI-Prolog 中，我们得到三个结果，所有 X = 1。
鉴于我们不关心匿名变量，是什么阻止了 SWI-Prolog 返回单个结果？为什么不执行此优化？
谢谢