小编xzh*_*zhu的帖子

我知道glBlendFunc是指定像素混合模式的函数调用.

我可以像Photoshop 一样进行乘法模式,其公式为

C = A * B

其中A是源像素,B是目标像素,C是最终结果.

使用glBlendFunc(GL_DST_COLOR,GL_ZERO)我会得到那个效果.

所以现在我的问题是如何使用屏幕模式？它的公式是:

C = 1 - (1 - A) * (1 - B)

这是一个简单的opengl程序.在绘制三角形之前,我正试图清除屏幕.我在我的init()函数中调用了glClear(),但它似乎无法清除屏幕.

#include <stdio.h>
#include <stdlib.h>
#include <GL/gl.h>
#include <GL/glu.h>
#include <GL/glut.h>

void myIdleFunc()
{
    glBegin(GL_TRIANGLES);
    {
        glColor3f(1.0f, 1.0f, 1.0f);
        glVertex2f(0.0f, 1.0f);
        glVertex2f(-1.0f, -1.0f);
        glVertex2f(1.0f, -1.0f);
    }
    glEnd();

    glFlush();

    usleep(1000000);
}

void init()
{
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glClear(GL_COLOR_BUFFER_BIT);
    glFlush();
}

int main(int argc, char **argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_SINGLE);
    glutCreateWindow("Hello, World!");

    init();

    glutIdleFunc(myIdleFunc);
    glutMainLoop();
    return 1;
}

这是一个屏幕截图,文本来自后面的gnome终端.

例如,我的脚本将使用生成大量输出process.stdout.write().我知道我可以less通过运行它来管它们node mycode.js | less -N.

但有没有办法让我可以在我的代码中进行管道处理,以便其他人可以正常运行我的代码node mycode.js并仍然可以将输出管道输入less？

我认为无限枚举器对于编写FP样式脚本非常方便,但我还没有找到一种在Ruby中构造这种结构的舒适方法.

我知道我可以明确地构建它:

a = Enumerator.new do |y|
    i = 0
    loop do
        y << i += 1
    end
end
a.next  #=> 1
a.next  #=> 2
a.next  #=> 3
...

但这对于这样一个简单的结构来说很烦人.

另一种方法是使用的"黑客" Float::INFINITY:

b = (1..Float::INFINITY).each
b = (1..1.0/0.0).each

这两个可能是我能给出的最笨拙的解决方案.虽然我想知道是否还有其他更优雅的方法来构建无限的枚举器.(顺便说一句,为什么Ruby不能制作inf或infinity作为文字Float::INFINITY？)

我需要创建一个包含30亿个布尔变量的数组.我的内存只有4GB,因此我需要这个数组非常紧凑(每个变量最多一个字节).从理论上讲,这应该是可能的.但是我发现Ruby在数组中为一个布尔变量使用了太多的空间.

ObjectSpace.memsize_of(Array.new(100, false))   #=> 840

每个变量超过8个字节.我想知道Ruby中是否有更轻量级的C数组实现.

除了一个小的配置文件,我还需要每个布尔这个数组可以快速访问,因为我需要尽可能快地翻转它们.

在文档中，有一个示例显示了annotation_raster如下用法。

ggplot(aes(x=mpg, y=wt), data=mtcars) +
  annotation_raster('red', -Inf, Inf, -Inf, Inf) +
  geom_point()

这工作正常，但是，当我将数据和 aes 移动到图层中时，突然它不再起作用了：

ggplot() +
  annotation_raster('red', -Inf, Inf, -Inf, Inf) +
  geom_point(aes(x=mpg, y=wt), data=mtcars)  # doesn't work

这令人困惑，因为对我来说这两个在语义上是相同的。

是否有第二行不起作用的原因，有没有一种方法可以annotation_raster在基础层早期不指定数据和 aes 的情况下使用？

在开发 R 包时，我通常只打开 Packrat 并使用本地化存储库，然后在会话中探索时进行开发。但是在发布包时，回忆并手动添加我在开发的包中使用过的每个依赖项是一件很头疼的事情。有（半）自动的方法来做到这一点吗？

比如在NodeJS开发中，我们直接使用即可npm install --save，依赖会自动添加到package.json.

有没有办法预先加载每个I运行时间之前的一些文件node(交互),只是喜欢.vimrc,.bash_profile等等？

我node主要使用交互式,我使用模块CSV很多,有没有办法避免require('./csv')每次开始打字node？

我正在寻找一个函数,可以有效地计算一个列表中的每个元素在另一个列表中的出现次数.它应该返回元素/计数元组的排序列表.这是规范:

countList :: Ord a => [a] -> [a] -> [(a, Integer)]
countList ['a', 'b', 'c', 'b', 'b'] ['a', 'b', 'x']
                               == [('a', 1), ('b', 3), ('x', 0)]
length (countList xs ys) == length ys

一个天真的实现将是:

countList xs = sort . map (id &&& length . (\ y -> filter (== y) xs))

这是O(n^2).但是,既然我们有了Ord a,那么使用更好的策略可以更快一些.我们可能首先对两个列表进行排序,然后在"爬梯"中对它们进行比较.

例如,以下是排序的两个列表.如果我必须这样做,我会使用指向每个列表中第一个元素的两个指针:

       i
       |
xs = ['a', 'b', 'b', 'b', 'c']
ys = ['a', 'b', 'x']
       |
       j

然后增加i的时候xs …

使用 React-Apollo，是否可以再次重新获取，直到获取的数据具有特定值？

假设我有一个组件会一直 ping 服务器，直到服务器返回某个响应。

graphql(gql`
  query {
    ping {
      response
    }
  }
`)(MyComponent)

服务器要么返回

ping: {
  response: "busy"
}

或者

ping: {
  response: "OK"
}

我希望这个组件每隔一秒就 ping 服务器（轮询），直到响应“正常”。使用 Apollo 最简单的方法是什么？