小编rpr*_*ero的帖子

我正在使用来自Data.Binary的Get monad从包含带符号16位整数的二进制文件中读取结构.我目前的代码如下:

data DetectorStats = DetectorStats Int16 Word8 Word8
                     Word8 Int16 Version Int16 
                     deriving Show

getDetectorStats :: Get DetectorStats
getDetectorStats = do
  productNumber <- getWord16be
  bitPerCoordinate <- getWord8
  energyCapability <- getWord8
  timingCapability <- getWord8
  clockFrequency <- getWord16be
  serialNumber <- getWord16be
  return (DetectorStats (unsafeCoerce productNumber )
                        bitPerCoordinate
                        energyCapability 
                        timingCapability
                        (unsafeCoerce clockFrequency)
                        firmwareVersion
                        (unsafeCoerce serialNumber))

我对使用unsafeCoerce不满意,但似乎没有办法直接读入Int16,也没有办法将Word16转换为Int16.有没有更好的方法来处理这个？

我正在编写一个从文件列表中读取的程序.每个文件都包含指向下一个文件的链接或标记它是链的末尾.

作为Haskell的新手,似乎处理这个的惯用方法是为此目的的可能文件的懒惰列表,我有

getFirstFile :: String -> DataFile
getNextFile :: Maybe DataFile -> Maybe DataFile

loadFiles :: String -> [Maybe DataFile]
loadFiles = iterate getNextFile . Just . getFirstFile

getFiles :: String -> [DataFile]
getFiles = map fromJust . takeWhile isJust . loadFiles

到现在为止还挺好.唯一的问题是,由于getFirstFile和getNextFile都需要打开文件,我需要将它们的结果放在IO monad中.这给出了修改后的形式

getFirstFile :: String -> IO DataFile
getNextFile :: Maybe DataFile -> IO (Maybe DataFile)

loadFiles :: String -> [IO Maybe DataFile]
loadFiles = iterate (getNextFile =<<) . Just . getFirstFile

getFiles :: String -> IO [DataFile] …

我目前有一个表达式很多的大表达式

Abs[-2 b + 2 d1 m + l Tan[\[Theta]]]

我知道,从我的问题的几何学,那

-2 b + 2 d1 m + l Tan[\[Theta]] > 0

但是,当我试图简化我的表达时,

Simplify[Abs[-2 b + 2 d1 m + l Tan[\[Theta]]], -2 b + 2 d1 m + l Tan[\[Theta]] > 0]

我回来了

Abs[-2 b + 2 d1 m + l Tan[\[Theta]]]

如何让Mathematica简化不必要的绝对值？

编辑1

我试图简化的完整表达是

-(1/(2 (m - Tan[\[Theta]])))
 Sqrt[1 + m^2] (B2 Sqrt[(-2 b + 2 d1 m + l Tan[\[Theta]])^2] + 
    B4 Sqrt[(-2 b + 2 d2 …

下面的python代码使用PyOpenCL 用数组b中的元素之和填充数组a_plus_b(这不是我的实际目标,但它是我能找到的最简单的代码仍然显示问题).

import pyopencl as cl
import numpy as np
import numpy.linalg as la

height = 50
width = 32

b = np.arange(width,dtype=np.int32)

ctx = cl.create_some_context()
queue = cl.CommandQueue(ctx)

mf = cl.mem_flags
b_buf = cl.Buffer(ctx, mf.READ_ONLY | mf.COPY_HOST_PTR, hostbuf=b)
dest_buf = cl.Buffer(ctx, mf.WRITE_ONLY, height*4)

prg = cl.Program(ctx, """
    __kernel void sum(__global const int *b, __global int *c)
    {
      int x = get_global_id(1);
      int y;
      c[x] = 0;
      for(y=0;y<get_global_size(0);y++) {
          c[x] += b[y];
      }
    }
    """).build()

prg.sum(queue, (width,height), None, …

我在让单元测试在cabal下运行时遇到了惊人的困难.我已经从cabal文档中逐字复制了测试代码,但更改模块名称除外

{-# LANGUAGE FlexibleInstances #-}
module Test.Integral ( tests ) where

import Distribution.TestSuite

instance TestOptions (String, Bool) where
    name = fst
    options = const []
    defaultOptions _ = return (Options [])
    check _ _ = []

instance PureTestable (String, Bool) where
    run (name, result) _ | result == True = Pass
                         | result == False = Fail (name ++ " failed!")

test :: (String, Bool) -> Test
test = pure

-- In actual usage, the instances 'TestOptions (String, …

我有一个Python的机器控制系统,目前看起来大致如此

goal = GoalState()
while True:
    current = get_current_state()
    move_toward_goal(current,goal)

现在,我正试图增加通过网络控制机器的能力.我想写的代码是这样的:

goal = GoalState()
while True:
    if message_over_network():
        goal = new_goal_from_message()
    current = get_current_state()
    move_toward_goal(current,goal)

将这种网络功能添加到我的应用程序中最简单,最Pythonic的方法是什么？套接字可以工作,认为他们并不特别感觉Pythonic.我看过XMLRPC和Twisted,但两者似乎都需要对代码进行重大修改.我也看过ØMQ,但感觉我正在添加一个外部依赖项,它没有提供任何我没有使用套接字的东西.

我并不反对使用我上面提到的任何系统,因为我认为失败可能是我的误解.我只是好奇地处理这个简单,常见的问题的惯用方法.

我有一个功能

slow :: Double -> Double

它经常被调用(数亿次),但只能调用大约一千个离散值.这似乎是备忘录的绝佳选择,但我无法弄清楚如何记住Double的功能.

制作列表的标准技术不起作用,因为它不是一个整体类型.我查看了Data.MemoCombinators,但它本身并不支持双打.有一个bits处理更多数据类型的函数,但Double 不是一个实例Data.Bits.

有一种优雅的方式来记住`慢？

我正在尝试从 XML 文档中提取一个转义节点。节点的原始文本如下所示：

<Notes>{&quot;Phase&quot;: 0, &quot;Flipper&quot;: 0, &quot;Guide&quot;: 0,     
&quot;Sample&quot;: 0, &quot;Triangle8&quot;: 0, &quot;Triangle5&quot;: 0,     
&quot;Triangle4&quot;: 0, &quot;Triangle7&quot;: 0, &quot;Triangle6&quot;: 0,     
&quot;Triangle1&quot;: 0, &quot;Triangle3&quot;: 0, &quot;Triangle2&quot;: 0}</Notes> 

我将文本提取如下：

infile = ET.parse("C:/userfiles/EXP011/SESAME_60/SESAME_60_runinfo.xml")
r = infile.getroot()
XMLNS = "{http://example.com/foo/bar/runinfo_v4_3}"
x=r.find(".//"+XMLNS+"Notes")
print(x.text)

我希望得到：

{"Phase": 0, "Flipper": 0, "Guide&quot": 0,     
"Sample": 0, "Triangle8": 0, "Triangle5": 0,     
"Triangle4": 0, "Triangle7": 0, "Triangle6": 0,     
"Triangle1": 0, "Triangle3": 0, "Triangle2": 0}

但是，相反，我得到了：

 {"Phase": 0, "Flipper": 0, "Guide": 0,      
 "Sample": 0, "Triangle8": 0, "Triangle5": 0,   
 "Triangle4": 0, "Triangle7": …

我有一个vector<int> foo和一个函数float bar(int)。使用algorithms图书馆，我可以填充vector<float> quux有

transform(foo.begin(), foo.end(), quux.begin(), bar);

我的foo函数碰巧很慢，我希望使用 TBB 库跨多个线程并行处理此代码。我认为这将是一个理想的情况，因为所有操作都是独立的。但是，似乎没有parallel_transform算法。我在parallel_for算法中看到的每个示例都将数据放回到原始数组中，这是我无法做到的，因为我正在更改类型。

我目前正在上课

template <typename T, typename Context>
class Foo {
    T value;
    Context context;
}

令人沮丧的是 的值T完全决定了 的值Context，因此第二项相当多余。在类似的情况下，我向类添加了一个Context类型，然后将函数编写为

template <typename T>
class Foo {
    T value; 
    T::Context context;
}

不幸的是，我在这里不能做同样的事情，因为 90% 的 foo 调用都在进行int，double而且我无法修改类型。

是否可以编写一个类型级函数来获取我的初始类型并返回相关类型。我正在想象类似的事情。

template <typename T> typename FooContext;
using FooContext<int> = std::string;
using FooContext<NodeValue> = NodeValue::Context;

template <typename T>
class Foo {
    T value; 
    FooContext<T> context;
}

作为一个额外的挑战，我们的项目是基于 C++17 的，因此不需要 C++20 概念的答案将被优先考虑。