小编spl*_*cer的帖子

我已经看到以下两种在C API中声明不透明类型的样式.使用一种风格而不是另一种风格有明显的优势吗？

选项1

// foo.h
typedef struct foo * fooRef;
void doStuff(fooRef f);

// foo.c
struct foo {
    int x;
    int y;
};

选项2

// foo.h
typedef struct _foo foo;
void doStuff(foo *f);

// foo.c
struct _foo {
    int x;
    int y;
};

我最近一直在玩OpenCL,我能够编写只使用全局内存的简单内核.现在我想开始使用本地内存,但我似乎无法弄清楚如何使用get_local_size()和一次get_local_id()计算一个"块"输出.

例如,假设我想将Apple的OpenCL Hello World示例内核转换为使用本地内存的内容.你会怎么做？这是原始的内核源代码:

__kernel square(
    __global float *input,
    __global float *output,
    const unsigned int count)
{
    int i = get_global_id(0);
    if (i < count)
        output[i] = input[i] * input[i];
}

如果这个例子不能轻易转换成显示如何使用本地内存的东西,那么任何其他简单的例子都可以.

我已经在命令行上使用svn超过5年了,但我正在考虑切换到GUI.Mac颠覆应用程序的两个国王似乎是版本和基石.我见过的大部分评论/评论都是在2008年Cornerstone首次发布的时候.它现在是2010年,两个应用程序都经历了重大变化.

过去一周我一直在运行两个应用程序的试用版,我仍然无法下定决心.你会推荐哪个？为什么？

我被赋予了完善编解码器库接口的任务。我们使用的是C ++ 17，我只能使用标准库（即没有Boost）。当前，有一Decoder类大致如下所示的类：

class Decoder : public Codec {

public:

    struct Result {
        vector<uint8_t>::const_iterator new_buffer_begin;
        optional<Metadata>              metadata;
        optional<Packet>                packet;
    };

    Result decode(vector<uint8_t>::const_iterator buffer_begin,
                  vector<uint8_t>::const_iterator buffer_end);

private:
    // irrelevant details
};

调用者实例化一个Decoder，然后通过以下方式将数据流馈送到解码器：

1. 从文件中读取大量数据（但将来可能还会有其他来源），并将其附加到vector<uint8_t>。

2. 调用该decode函数，并为其向量传递迭代器。

3. 如果返回Result的new_buffer_begin与buffer_begin传递给的相同，则decode意味着缓冲区中没有足够的数据来解码任何内容，并且调用方应返回到步骤1。否则，调用方将使用已解码的Metadata或Packet对象。 ，然后返回到步骤2，new_buffer_begin用于下一遍。

我对这个介面不满意，需要改善的地方：

• 使用vector<uint8_t>::const_iterator似乎过于具体。有没有更通用的方法不强制调用者使用vector？我当时正在考虑仅使用C风格的界面；一个uint8_t *和一个长度。有没有相当通用的C ++替代品？

• 如果有足够的数据来解码某些内容，则只有metadata 或 packet将有一个值。我认为std::variant2个回调（每种类型一个）将使此代码更具自说明性。我不确定哪个更惯用。每种方法的优缺点是什么，是否有更好的方法？

假设您在一个数组中有100000000个32位浮点值,并且每个浮点数的值都在0.0到1.0之间.如果你试图将它们全部加起来像这样

result = 0.0;
for (i = 0; i < 100000000; i++) {
    result += array[i];
}

你遇到的问题result远远大于1.0.

那么有哪些方法可以更准确地执行求和？

我正在尝试并行化C中的卷积函数.这是原始函数,它会卷积两个64位浮点数组:

void convolve(const Float64 *in1,
              UInt32 in1Len,
              const Float64 *in2,
              UInt32 in2Len,
              Float64 *results)
{
    UInt32 i, j;

    for (i = 0; i < in1Len; i++) {
        for (j = 0; j < in2Len; j++) {
            results[i+j] += in1[i] * in2[j];
        }
    }
}

为了允许并发(没有信号量),我创建了一个函数来计算results数组中特定位置的结果:

void convolveHelper(const Float64 *in1,
                    UInt32 in1Len,
                    const Float64 *in2,
                    UInt32 in2Len,
                    Float64 *result,
                    UInt32 outPosition)
{
    UInt32 i, j;

    for (i = 0; i < in1Len; i++) {
        if (i > outPosition)
            break; …

我想构建一个GUI,每个像素都在我的控制之下(即不使用GTK +提供的标准小部件).Renoise就是我想要制作的一个很好的例子.

是获得Xlib或XCB级别的最佳方式,还是可以通过GTK +等更高级别的框架实现这一目标(甚至可能是PyGTK)？我应该在开罗看画吗？

如果可能的话,我想在Python或Ruby中工作,但C也很好.

为什么以下bash脚本只打印出来variable worked？

#! /bin/bash

foo=baaz
regex='ba{2}z'

if [[ $foo =~ 'ba{2}z' ]]; then
    echo "literal worked"
fi

if [[ $foo =~ $regex ]]; then
    echo "variable worked"
fi

bash文档中是否有一些内容表明=~运算符只适用于变量而不是文字？此限制是否适用于任何其他运营商？

比方说,我有3个32位浮点值,a,b,和c,这样(a + b) + c != a + (b + c).是否存在可能类似于Kahan求和的求和算法,它保证这些值可以按任何顺序求和并且总是达到完全相同(相当准确)的总和？我正在寻找一般情况(即不是仅涉及3个数字的解决方案).

是任意精度算术的唯一出路吗？我正在处理非常大的数据集,所以我希望尽可能避免使用任意精度算术的开销.

谢谢!

比方说,我有以下数组:

files=( "foo" "bar" "baz fizzle" )

我想通过一个命令来管道这个数组的内容,比如说sort,好像每个元素都在一个文件中的一行.当然,我可以将数组写入临时文件,然后使用临时文件作为输入sort,但我想尽可能避免使用临时文件.

如果"bar fizzle"没有那个空格字符,我可以这样做:

echo ${files[@]} | tr ' ' '\012' | sort

有任何想法吗？谢谢!