小编use*_*197的帖子

我无法让 zmq 服务器和客户端与 IPv6 进行通信，而它可以通过 C++ 轻松地与 IPv4 配合使用。

这是我的 ip a 显示的：

2: enp0s31f6: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc fq_codel state UP group default qlen 1000
link/ether 1c:1b:0d:0c:d7:bc brd ff:ff:ff:ff:ff:ff
inet 192.168.35.208/24 brd 192.168.35.255 scope global dynamic enp0s31f6
   valid_lft 7193sec preferred_lft 7193sec
inet6 fe80::fb7:c6df:9d3a:3d7b/64 scope link 
   valid_lft forever preferred_lft forever

服务器：

zmq::context_t context(1);
zmq::socket_t server (context, ZMQ_REP);

server.setsockopt( ZMQ_IPV6, 1);

server.bind("tcp://*:5555%enp0s31f6");

客户：

zmq::context_t context(1);
zmq::socket_t client (context, ZMQ_REQ);

client.setsockopt( ZMQ_IPV6, 1);

client.connect("tcp://[fe80::fb7:c6df:9d3a:3d7b]:5555%enp0s31f6");

服务器等待监听，客户端发送消息，服务器永远不会收到它。IPv4 运行良好。

怎么了？

模块joblib提供了一个简单的帮助程序类来使用多处理编写并行 for 循环。

此代码使用列表理解来完成这项工作：

import time
from math import sqrt
from joblib import Parallel, delayed

start_t = time.time()
list_comprehension = [sqrt(i ** 2) for i in range(1000000)]
print('list comprehension: {}s'.format(time.time() - start_t))

大约需要0.51s

list comprehension: 0.5140271186828613s

此代码使用joblib.Parallel()构造函数：

start_t = time.time()
list_from_parallel = Parallel(n_jobs=2)(delayed(sqrt)(i ** 2) for i in range(1000000))
print('Parallel: {}s'.format(time.time() - start_t))

大约需要31秒

Parallel: 31.3990638256073s

这是为什么？不应该Parallel()比非并行计算更快吗？

这是其中的一部分cpuinfo：

processor       : 0
vendor_id       : GenuineIntel
cpu family      : 6
model           : 79
model …

所以,我正在探索0MQ作为我的集群应用程序的消息传递协议.它提供了我需要的那种异步通信.

到目前为止,我已经初步成功制作了一个原型.我能够使用几种不同类型的模式发送和接收消息.

我目前正试图PUB/SUB通过REP/REQ"握手" 获得一个初始同步模式.ZeroMQ指南在"节点协调"下描述了这种方法.而且该方法效果很好.唯一的问题是0MQ似乎正在吃掉约50%的信息,或者至少是其中的数据.

我正在使用Qt,因此消息包含一个QString.我将字符串打包成a QByteArray使用a QDataStream.然后,我通过QByteArray"电线"并在另一侧打开包装.我经常使用这种方法通过其他协议(如tcp套接字)进行通信,并且效果很好.

我有4个"工人"连接到via PUB/SUB和REQ/REP一个"经理".在大多数运行中,至少1个,最多3个"工人"同步很好.但是,当他们不这样做时,他们会收到一个空字符串.

这是4个客户的日志:

alicia:

[09:18:15.337] [Info] Logging initialized
[09:18:15.337] [Debug] Initializing client 
                       alicia
[09:18:15.337] [Debug] Attempting to receive START signal from server
[09:18:15.340] [Info] Received message: 
                      START
[    09:18:15.341] [Debug] Recieved a SYNC message
                       SYNC
[09:18:15.341] [Info] Received START signal from manager
[09:18:15.341] [Info] Received message: 
                      2

brenda:

[09:18:15.337] [Info] Logging initialized
[09:18:15.337] [Debug] Initializing client 
                       brenda
[09:18:15.337] …

目标:

我想为不经常更改的数据实现硬编码查找表,但是当它确实发生更改时,我希望能够快速更新程序并重建.

计划:

我的计划是定义一个自定义数据类型...

private class ScalingData
{
    public float mAmount;
    public String mPurpose;
    public int mPriority;

    ScalingData(float fAmount, String strPurpose, int iPriority)
    {
        mAmount = fAmount;
        mPurpose = strPurpose;
        mPriority = iPriority;
    }
}

然后,在主类中,像这样对数组进行硬编码......

public static ScalingData[] ScalingDataArray =
{
        {1.01f, "Data point 1", 1},
        {1.55f, "Data point 2", 2}
};

但是,这不构建.我一直看到消息" Type mismatch: cannot convert from float[] to ScalingData".

我怎样才能实现目标？

UPDATE

到目前为止,我已尝试实施这些建议,但仍然遇到错误......

代码如下:

public class CustomConverter
{
    //Lookup Table
    private static ScalingData[] ScalingDataArray =
    {
        new …

我一直在Windows中使用MATLAB进行模拟.但是,现在我正在研究Ubuntu,所以当我运行一个加载包含所需数据的文件的模拟时:

auxiliar_nm1 = load('C:\Users\Miguel\Dropbox\Tesina\Simulaciones\Quadrotor Simulation\M Model 1\auxiliar.txt', 'auxiliar_nm1');

我收到以下错误:

Unable to read file 'C:\Users\Miguel\Dropbox\Tesina\Simulaciones\Quadrotor Simulation\M Model 1\auxiliar.txt'. No such file or directory.

我知道我可以修改路径,所以这个问题将会解决,但我想知道是否可以在MATLAB中确定操作系统,并根据这个参数做出决定,所以这个脚本可用于两种操作系统(Windows和Ubuntu).

我在python中有以下代码:

def P(z, u0):
    x = np.inner(z, u0)
    tmp = x*u0
    return (z - tmp)


def powerA2(A, u0):
    x0 = np.random.rand(len(A))
    for i in range(ITERATIONS):
        x0 = P(np.dot(A, x0), u0)
        x0 = x0 / np.linalg.norm(x0)
    return (np.inner(np.dot(A, x0), x0))

np是numpy包.

我有兴趣为大小为100,000*100,000的矩阵运行此代码,但似乎这个程序没有机会快速运行(我需要多次运行,大约10,000次).

是否有可能像多线程这样的技巧在这里起作用？

还有什么有助于加速它？

我正在使用PUB/ SUB设计，我的问题是：

我.bind()可以在另一个套接字插入后再访问该端口吗.connect()，还是应该.bind()在另一个套接字尝试访问.connect()相同的地址之前访问该端口？

换一种说法：

.bind()和的顺序.connect()重要吗？

（我认为这个问题不是特定于PUB/ SUB而是与任何设计有关）。

我使用私有字段(PushSocket- zmq_push socket for netmq)

private PushSocket _pushSocket;

以及在不同线程中使用此套接字的两种方法

public void Method1()
{
    //.....//
    _pushSocket.SendFrame(....);
    //.....//
}

public void Method2()
{
    //.....//
    _pushSocket.SendFrame(....);
    //.....//
}

我应该使用lock或其他同步原语吗？

我是新手在两个python和opencv,我在检测以下图像,其具有放置在地面黑线带中的行面临的一个问题:

我使用了以下代码:

gray = cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)
edges = cv2.Canny(gray,50,150,apertureSize = 3)
print img.shape[1]
print img.shape
minLineLength = img.shape[1]-1
maxLineGap = 10
lines = cv2.HoughLinesP(edges,1,np.pi/180,100,minLineLength,maxLineGap)
for x1,y1,x2,y2 in lines[0]:
    cv2.line(img,(x1,y1),(x2,y2),(0,255,0),2)

但是它无法准确地检测到线条,只能在底部的第一个黑色条带上绘制一条绿线,甚至不覆盖整条线条,
另外,
请建议一种获取y每条线路的坐标的方法.

我有一个用 Python 训练的 XGBoost 树结构的转储文件。该结构有 377 棵树，文件大约有 50,000 行。我想将此结构转换为 MQL4 代码，或者可以说是 C 代码。文本文件看起来像这样：

booster[0]:
0:[inp0<6.85417] yes=1,no=2,missing=1
1:[inp10<1.00054] yes=3,no=4,missing=3
    3:[inp21<0.974632] yes=7,no=8,missing=7
        7:[inp22<1.01021] yes=15,no=16,missing=15
            15:[inp15<0.994931] yes=31,no=32,missing=31
                31:[inp12<0.999151] yes=63,no=64,missing=63
                    63:[inp23<0.957624] yes=111,no=112,missing=111
                        111:leaf=0.163636
                        112:leaf=-0.36
                    64:leaf=0.323077
                32:[inp19<0.993949] yes=65,no=66,missing=65
                    65:[inp23<0.931146] yes=113,no=114,missing=113
                        113:leaf=-0
                        114:[inp23<0.972193] yes=161,no=162,missing=161
                            161:leaf=-0.421782
                            162:leaf=-0.133333
                    66:[inp2<61] yes=115,no=116,missing=115
                        115:leaf=0.381818
                        116:leaf=-0.388235
            16:[inp17<0.985065] yes=33,no=34,missing=33
                33:leaf=-0.381818
                34:[inp23<0.946341] yes=67,no=68,missing=67
                    67:leaf=-0.36
                    68:[inp12<1.00121] yes=117,no=118,missing=117
                        117:[inp19<0.989751] yes=163,no=164,missing=163
                            163:leaf=0.367742
                            164:leaf=-0.0666667
                        118:[inp0<4.29167] yes=165,no=166,missing=165
                            165:leaf=-0
                            166:leaf=-0.3
        8:[inp11<0.999875] yes=17,no=18,missing=17
            17:[inp7<134] yes=35,no=36,missing=35
                35:[inp9<62] yes=69,no=70,missing=69
                    69:[inp8<26] yes=119,no=120,missing=119
                        119:[inp23<0.993382] yes=167,no=168,missing=167
                            167:leaf=-0.211765
                            168:leaf=0.27
                        120:[inp21<0.989946] yes=169,no=170,missing=169
                            169:leaf=-0.392308
                            170:leaf=-0.161421
                    70:[inp17<0.997] yes=121,no=122,missing=121
                        121:[inp13<0.999021] yes=171,no=172,missing=171 …