Debugging 在Haskell中实现LLL算法

我正在Haskell中实现LLL基约简算法。我的代码是基于。这是我到目前为止所拥有的。为代码转储道歉；我强烈怀疑问题在于

lll

，但我会尽全力以防万一

import Linear as L

f v x = v `L.dot` x

gram_schmidt b = 
    let aux vs us =
            case vs of
            v:t -> let vus = map (\u -> project u v) us
                       s = foldr (^+^) zero vus
                       u = v ^-^ s in
                   aux t (us++[u])
            [] -> us
    in aux b []

swap :: Int -> Int -> [a] -> [a]
swap i j xs =
    let elemI = xs !! i
        elemJ = xs !! j
        left = take i xs
        middle = take (j - i - 1) (drop (i + 1) xs)
        right = drop (j + 1) xs
    in  left ++ [elemJ] ++ middle ++ [elemI] ++ right

update i xs new =
    let left = take (i-1) xs
        right = drop (i) xs
    in left ++ [new] ++ right

sort_vecs vs = map snd (sort (zip (map norm vs) vs))

lll :: Int -> [[Double]] -> Double -> [[Double]]
lll d b delta =
    let b' = gram_schmidt b
        aux :: [[Double]] -> [[Double]] -> Int -> [[Double]]
        aux b b' k =
                if k >= d then
                    b
                else
                    let aux2 :: [[Double]] -> [[Double]] -> Int -> [[Double]]
                        aux2 b b' j =
                            if j < 0 then
                                let mu = (f (b!!k) (b'!!(k-1))) / (f (b'!!(k-1)) (b'!!(k-1))) in
                                if f (b'!!k) (b'!!k) >= (delta-mu^2) * f (b'!!(k-1)) (b'!!(k-1)) then
                                    aux b b' (k+1)
                                else
                                    let bb = swap k (k-1) b
                                        bb' = gram_schmidt bb in
                                    aux bb bb' (max (k-1) 1)
                            else
                                let mu = (f (b!!k) (b'!!j)) / (f (b'!!j) (b'!!j)) in
                                if abs mu > 0.5 then
                                    let bk = b!!k
                                        bj = b!!j
                                        bb = update k b (bk ^-^ (fromIntegral (round mu)) *^ bj)
                                        bb' = gram_schmidt bb in
                                    aux2 bb bb' (j-1)
                                else
                                    aux2 b b' (j-1)
                    in aux2 b b' (k-1)
    in sort_vecs (aux b b' 1)

导入线性为L
f v x=v`L.dot`x
格拉姆施密特b=
让奥克斯对我们=
案例vs
v:t->let vus=map（\u->project u v）us
s=foldr（^+^）零vus
u=v^-^s英寸
辅助t（us++[u]）
[]->美国
在辅助项b[]
交换：：Int->Int->[a]->[a]
交换i j x=
让elemI=xs！！我
elemJ=xs！！J
左=取i x
中间=取（j-i-1）（下降（i+1）x）
右=下降（j+1）x
左++[elemJ]++中++[elemI]++右
更新i-xs-new=
让左=取（i-1）xs
右=下降（i）x
左++[新]++右
sort_vecs vs=map snd（排序（zip（map norm vs）vs））
lll:：Int->[[Double]]->Double->[[Double]]
德尔塔=
设b'=gram_-schmidt b
辅助：：[[Double]]->[[Double]]->Int->[[Double]]
辅助b'k=
如果k>=d，则
B
其他的
让aux2:：[[Double]]->[[Double]]->Int->[[Double]]
aux2 b'j=
如果j<0，则
设mu=（f（b！！k）（b'！！（k-1））/（f（b'！！（k-1））（b'！！（k-1）））in
如果f（b'！！k）（b'！！k）>=（δμ^2）*f（b'！！（k-1））（b'！！（k-1）），那么
辅助b'（k+1）
其他的
设bb=swap k（k-1）b
bb'=克施密特bb英寸
辅助bb'（最大（k-1）1）
其他的
让mu=（f（b！！k）（b'！！j））/（f（b'！！j）（b'！！j））在
如果abs mu>0.5，则
让bk=b！！K
bj=b！！J
bb=更新kb（bk^-^（从整数（整数单位））*^bj）
bb'=克施密特bb英寸
aux2 bb’（j-1）
其他的
aux2 b’（j-1）
在aux2 b（k-1）中
在排序向量中（辅助b'1）

---

我的问题是，它似乎找到了子晶格的基础。特别是，

lld[[-0.8526334764831849，-3.12500000000004e-2]，-1.2941941738241598,4.419417382415916e-2]]0.75

返回

[[0.41107277914220997,0.10669417382415924]，-1.2941941738241598,4.419417382415916e-2]，

，这是索引-2子格的基础，与几乎平行的基础。我一直盯着这个代码看了很久都没有用（我原以为

update

有问题，其中

（I-1）

应该是

（I）

，而

（I）

应该是

（I+1）

，但这导致了一个无限循环）。非常感谢您的帮助。

我建议将此文件拆分。没有什么比一个结在一起的巨大函数更难调试的了。引用透明性意味着您始终可以拆分子函数并单独调试它们，因为它们不会影响彼此的状态。是否从

线性

包中选择

线性

？如果是这样，那么

[]

的

度量实例在哪里？@amalloy谢谢，我会试试看。@Carl我还是个新手，所以我不确定度量实例是什么，但我在使用线性的方法列出双精度列表时没有遇到任何问题。关于Linear/[]我应该做些什么修改吗？@zjs哦，我想我是在看文档，寻找一个非常旧的
Linear
版本，而这个版本并不存在。跟随谷歌链接到黑客的负面影响。。。。