小编wal*_*mat的帖子

我有那些数组:

a = np.array([
     [1,2],
     [3,4],
     [5,6],
     [7,8]])

b = np.array([1,2,3,4])

我想让它们像这样繁殖:

[[1*1, 2*1],
[3*2, 4*2],
[5*3, 6*3],
[7*4, 8*4]]

...基本上out[i] = a[i] * b[i],这里a[i].shape是(2,)和b[i]则是标量.

有什么诀窍？np.multiply似乎不起作用:

>>> np.multiply(a, b)
ValueError: operands could not be broadcast together with shapes (4,2) (4)

我想知道如何正确地完成多处理.假设我有一个[1,2,3,4,5]由函数生成的列表,该列表f1被写入Queue(左绿色圆圈).现在我开始从该队列中拉出两个进程(通过f2在进程中执行).他们处理数据,比如说:将值加倍,然后将其写入第二个队列.现在,函数f3读取此数据并将其打印出来.

在函数内部有一种循环,试图永远从队列中读取.我该如何停止这个过程？

想法1

f1不仅发送列表,还发送一个None对象或一个custon对象,class PipelineTerminator: pass或者一些只是一直向下传播的对象.f3现在等待None来,当它在那里时,它突然出现了.问题:两个f2s 中的一个可能会读取并传播,None而另一个仍在处理数字.然后最后一个值丢失.

想法2

f3是f1.因此,该函数f1生成数据和管道,生成流程f2并提供所有数据.产卵和喂食后,它会监听第二根管道,只需计算和处理收到的物体.因为它知道输入了多少数据,所以它可以终止执行的进程f2.但如果目标是设置处理管道,则不同的步骤应该是可分离的.因此f1,f2并且f3是管道的不同元素,并且昂贵的步骤是并行完成的.

想法3

管道的每个部分都是一个功能,该功能可以根据需要生成流程并负责管理它们.它知道,有多少数据进入,返回了多少数据(yield可能).因此传播None对象是安全的.

setup child processes 

execute thread one and two and wait until both finished

thread 1:
    while True:
        pull from input queue
        if None: break and set finished_flag …

我有一个期望std::vector(调用它A)的算法.不过,我已经B有N + 2条目和我基本上要为通过B.data() + 2,因此该算法得到最后N的条目B.如果A被修改,那么也是如此B.

当使用double*指针时,我非常清楚我应该如何制作它,但这对std::vectors 也是可能的吗？我的意思是,矢量的好处是它为我处理内存,我现在想要的是禁止它(如果B或被A破坏,它们应该保持指向的数据不变).

像这样:

std::vector< double > B({1,2,3,4,5});
std::vector< double > A(B.data() + 2, B.size() - 2);

// A and B share data now. A is 3, 4, 5

我知道通过采用一对迭代器可以更好地为此目的设计算法,但这不在我手中.

UPDATE

(在评论中,有人希望看到签名,这里是)

nlopt::result nlopt::opt::optimize(std::vector<double> &x, double &opt_f);

但是,我的初衷是非常聪明,让算法在我的向量中优化direclty B,所以我最终得到的是这样的:

std::vector< double > B(N + 2);
// do something with …

我有一个do_magic方法,需要一个双倍,并添加42.我想这种方法应用到的每个系数Eigen::Matrix或Eigen::Array(这意味着,我不会介意,如果这是唯一可能与这两种类型中的一种).

这可能吗？

像这样:

Eigen::MatrixXd m(2, 2);    
m << 1,2,1,2;    
m.applyCoefficientWise(do_magic);
// m is now 43, 44, 43, 44

我有以下直接结构:

src
  +-- lib1
    +-- lib1.h
  +-- lib2
   +-- lib2.h

双方lib1并lib2都打算进行分配(安装).lib2利用lib1,所以它需要一些包括:

#include "../lib1/lib1.h" // 1
#include "lib1/lib1.h"    // 2
#include <lib1/lib1.h>    // 3

(1)是直截了当的方式,但是非常不灵活.(2)是我目前使用的方式,但构建系统需要知道src需要添加到包含路径.(3)在分发方面对我来说似乎是最好的,因为可以假设标题位于标准位置,但对于我来说,构建系统如何处理它(在这种情况下,lib1需要先安装)lib2可以编译).

推荐的方式是什么？

我有一个在无限循环中做一些工作的对象.该main()实例化对象,并调用该run()方法.由于我不想使用线程,我需要一个解决方案来使我的对象停止运行.下面你看看我想出了什么.

struct Foo
{
    void run()
    {
        running = 1;
        while (running) 
            do_something_useful();

        std::cout << "Execution stopped." << std::endl;
    }

    bool running;

    void catch_signal(int signal)
    {
        std::cout << "Caught signal " << signal << std::endl;
        if( signal == SIGTERM ) 
            running = false;
    }

};

如您所见,我需要异步发送信号.因此,我使用信号处理程序和sigaction.下面main我可以想象使用.

int main(int argc, char** argv)
{
    Foo foo;
    struct sigaction sigIntHandler;

    boost::function< void (int) > f;
    f = std::bind1st(
      std::mem_fun(&Foo::catch_signal), &foo);
    f(5);  // this call works …

以下代码执行compile(g++ 4.7.2):

#include <chrono>

typedef std::chrono::duration< double > double_prec_seconds;
typedef std::chrono::time_point< std::chrono::system_clock > timepoint_t;

void do_something( const timepoint_t& tm )
{
    // ...
}

int main( int argc, char** argv )
{
    timepoint_t t0 = std::chrono::system_clock::now();
    timepoint_t t1 = t0 + std::chrono::seconds(3);

    // timepoint_t t3 = t0 + double_prec_seconds(3.14);
   auto t3 = t0 + double_prec_seconds(3.14);

    do_something( t1 );
}

我的问题是我不知道什么类型t3.它不是timepoint_t,并且用明确给出的类型取消注释行将无法编译.与函数调用相同的:我不能叫do_something用t3.

所以我的问题是:

• 为什么转换失败？
• 具有双精度秒持续时间的最佳方法是什么？

我知道我可以使用这样的额外演员

// this works
timepoint_t t3 = …

我有一张图片img:

>>> img.shape
(200, 200, 3)

在像素(100,100)上我有一个很好的颜色:

>>> img[100,100]
array([ 0.90980393,  0.27450982,  0.27450982], dtype=float32)

现在我的问题是:这张图片中有多少种不同的颜色,我该如何枚举它们？

我的第一个想法是numpy.unique(),但不知怎的,我正在使用这个错误.

我设法编译我的.proto文件,如下所示:

def build(bld):
    bld(rule='protoc --cpp_out=. -I.. ${SRC}', source='a.proto b.proto', name='genproto')

似乎工作得很好,当我对源文件进行更改时,它们会被重新编译,等等.但结果将文件叫build/a.pb.cc和build/b.pb.cc我需要包括到我的主要节目源列表.当然我知道如何从我的协议缓冲区文件名中手动构造它们,但我不认为这是要走的路.任何人都可以提供一些提示吗？

最好的问候,菲利普

UPDATE

在IRC人员的帮助下,我能够设法构建一个工具,如下所示.

#!/usr/bin/env python
# encoding: utf-8
# Philipp Bender, 2012

from waflib.Task import Task
from waflib.TaskGen import extension 

"""
A simple tool to integrate protocol buffers into your build system.

    def configure(conf):
        conf.load('compiler_cxx cxx protoc_cxx')

    def build(bld):
    bld.program(source = "main.cpp file1.proto proto/file2.proto", 
            target = "executable") 

"""

class protoc(Task):
    run_str = '${PROTOC} ${SRC} --cpp_out=. -I..'
    color = 'BLUE'
    ext_out = ['.h', 'pb.cc'] …

题

我想以发布订阅的方式在应用程序之间传递数据。数据产生的速度可能比消耗的速度快得多，而且消息会丢失，这不是问题。想象一个快速传感器和一个慢速传感器数据处理器。为此，我使用 redis pub/sub 并编写了一个类作为订阅者，接收每条消息并将其放入缓冲区。当“真实”函数请求消息时，缓冲区会在新消息进入或无效时被覆盖。因此，当我问这个类时，我立即得到了响应（提示我的函数比传入的数据慢）或者我必须等待（提示我的函数比数据快）。

这对于数据快速传入的情况非常有效。但对于其中涉及在相对较少的数据，让我们说每五秒钟，但这不是工作：想象我的消费者被轻微推出后生产者，第一消息丢失和我的消费者需要等待将近五秒钟，直到它可以开始工作.

我想我必须用Redis工具来解决这个问题。而不是pub/sub，我可以简单地使用get/set方法，从而将缓存功能直接放入 Redis 中。但是，我的消费者将不得不轮询数据库，而不是我目前拥有的事件魔法。密钥可能看起来像“key:timestamp”，我的消费者现在必须get key:*永久比较时间戳，我认为这会导致大量负载。自然没有睡眠的可能性，因为虽然我不关心丢失的消息（我无能为力），但我确实关心延迟。

是否有人将 Redis 用于类似的事情，并且可以给我一些有关如何巧妙使用 Redis 工具和数据结构的提示？

编辑

理想情况下，我的程序流程如下所示：

• 启动程序
• key从 Redis 中检索
• 告诉Redis，“嘿，通知我”的变化key。
• 异步启动一些东西，对新消息进行回调。

通过写这篇文章，一个想法出现了：发布者不仅发布message主题key，而且还发布set key message. 这样，应用程序最初可以get，然后subscribe。

好主意还是不是真的？

得到以下答案后我做了什么（接受的答案）

密钥空间通知正是我在这里所需要的。Redis 作为信息的主要来源，我的客户端订阅了keyspace 通知，它通知订阅者有关影响特定键的事件。现在，在我的客户端的异步部分，我订阅了有关我感兴趣的密钥的通知。这些通知设置了一个key_has_updates标志。当我需要该值时，我get会从 Redis 中提取该值并取消设置该标志。使用未设置的标志，我知道服务器上没有该键的新值。如果没有键空间通知，这将是我需要轮询服务器的部分。优点是我可以使用各种数据结构，不仅是pub/sub机制，而且一个错过第一个事件的慢连接器总是能够get初始值，它pub/sib会丢失。

当我需要该值时，我从 Redis 获取该值并将标志设置为 false。