小编Mic*_*l T的帖子

我想组合两个numpy数组来生成一个数组,每个数组的值最大.

import numpy as np

a  = np.array([[ 0.,  0.,  0.5],
               [ 0.1,  0.5,  0.5],
               [ 0.1,  0.,  0.]])

b  = np.array([[ 0.,  0.,  0.0],
               [ 0.5,  0.1,  0.5],
               [ 0.5,  0.1,  0.]])

我想生产

array([[ 0.,  0.,  0.5],
       [ 0.5,  0.5,  0.5],
       [ 0.5,  0.1,  0.]])

我知道你能做到

a += b

结果

array([[ 0. ,  0. ,  0.5],
       [ 0.6,  0.6,  1. ],
       [ 0.6,  0.1,  0. ]])

这显然不是我追求的.这似乎是一个简单的问题,我认为最有可能.

我目前正在试验数据类型,我遇到了涉及数据构造函数的多个声明的问题.

data DBPosition = Unknown
                | Omega Integer
                | Delta Integer
                deriving (Show, Eq, Ord)

data DBGeometry = Unknown | Cis | Trans
                deriving (Show, Eq, Ord)

data DoubleBond = DoubleBond DBPosition DBGeometry
                deriving (Show, Eq, Ord)

如果我要创建一个诸如 - 的值let bond = DoubleBond Unknown Unknown,那么可以推断出第一个Unknown具有类型,DBPosition而第二个Unknown具有类型DBPosition.不幸的是,这种情况并非如此:

test.hs:6:27:
Multiple declarations of `Unknown'
Declared at: test.hs:1:27
             test.hs:6:27
Failed, modules loaded: none.

是否有可用于解决此问题的语言扩展？

假设我们将数据类型定义为

data A a = A' a deriving Show 

我们有

A :: * -> *

然后,我们可以将A作为以下实例Functor:

instance Functor A where fmap f (A' x) = A' (f x)

这允许我们创建类型的值A并使用fmap将函数应用于包装的值

Prelude> let x = A' 1
Prelude> fmap (+1) x
A' 2

现在,如果我们定义A为

data A = A' Int deriving Show

那种A是

A :: *

因此,我们无法创建AFunctor的实例 -

instance Functor A where fmap f (A' x) = A' (f x)

<interactive>:4:18: …

以下数据类型是磷脂酸(PA-脂质的亚类)的代表.使用质谱法,可以获得不同水平的结构细节(即,从简单地知道脂质的质量一直到具有完整的结构表征).

我目前有PA数据类型 -

data PA   = ClassLevelPA       IntegerMass
          | CombinedRadylsPA   CombinedRadyls
          | UnknownSnPA        Radyl Radyl
          | KnownSnPA          { paSn1 :: Radyl
                               , paSn2 :: Radyl }
          deriving (Show, Eq, Ord)

这将构造函数与记录语法结合在一起(不太可能是一个坏主意).或者,我可以做以下其中一项 -

data PA   = ClassLevelPA       { paIntegerMass :: IntegerMass }
          | CombinedRadylsPA   { paCombinedRadyls :: CombinedRadyls }
          | UnknownSnPA        { paR1 :: Radyl 
                               , paR2 :: Radyl }
          | KnownSnPA          { paSn1 :: Radyl
                               , paSn2 :: Radyl }

data PA   = ClassLevelPA       IntegerMass
          | CombinedRadylsPA   CombinedRadyls
          | UnknownSnPA …

我在编写解析器时遇到了问题.具体来说,我想成为不同类型的返回值.例如,我有两种不同的数据类型FA,PA代表两种不同的脂类 -

data FA = ClassLevelFA IntegerMass
        | FA           CarbonChain
        deriving (Show, Eq, Ord)

data PA   = ClassLevelPA       IntegerMass
          | CombinedRadylsPA   TwoCombinedRadyls
          | UnknownSnPA        Radyl Radyl
          | KnownSnPA          Radyl Radyl
          deriving (Show, Eq, Ord)

使用attoparsec,我已经构建了解析器来解析脂质速记符号.对于上面的数据类型,我有解析器faParser和paParser.我希望能够解析一个FA或PA.但是,由于FA和PA不同的数据类型,我不能做以下 -

inputParser =  faParser
           <|> paParser

我最近了解了GADT,我认为这可以解决我的问题.因此,我去做了一个GADT和一个eval函数并改变了解析器faParser和paParser.-

data ParsedLipid a where
  ParsedFA :: FA -> ParsedLipid FA
  ParsedPA :: PA -> ParsedLipid PA …

在博客文章http://galvanist.com/post/83741037068/adding-badly-under-python-julia-go中,作者使用一种简单的算法来比较各种语言(包括Haskell)的性能.在Haskell示例中,作者使用递归函数.作为练习,我想使用ST monad来允许本地可变状态.这是有效的,但递归函数比我使用ST monad的函数快得多.

递归函数 -

peanoAdd :: Int -> Int -> Int
peanoAdd 0 y = y
peanoAdd x y = peanoAdd (x - 1) (y + 1)

main :: IO ()
main = do
    let a = 64000000 :: Int
    let b = 64000000 :: Int
    let n = peanoAdd a b
    print n

128000000

real    0m0.583s
user    0m0.480s
sys     0m0.096s

使用ST monad-

import Control.Monad.ST
import Data.STRef
import Control.Monad.Loops

peanoAdd :: Int -> Int -> Int
peanoAdd …