小编Jon*_*fer的帖子

鉴于此代码:

#include <string.h>

int equal4(const char* a, const char* b)
{
    return memcmp(a, b, 4) == 0;
}

int less4(const char* a, const char* b)
{
    return memcmp(a, b, 4) < 0;
}

x86_64上的GCC 7引入了第一种情况的优化(Clang已经做了很长时间):

    mov     eax, DWORD PTR [rsi]
    cmp     DWORD PTR [rdi], eax
    sete    al
    movzx   eax, al

但第二种情况仍然是memcmp():

    sub     rsp, 8
    mov     edx, 4
    call    memcmp
    add     rsp, 8
    shr     eax, 31

是否可以对第二种情况应用类似的优化？什么是最好的装配,有没有明确的理由为什么它没有完成(由GCC或Clang)？

在Godbolt的Compiler Explorer上看到它:https://godbolt.org/g/jv8fcf

我从下载的示例中获取了这段代码:

bool ChatServer::event(QEvent * event)
{
    if(event->type() == QEvent::User)
    {
        UserEvent * ue = static_cast<UserEvent *>(event);
        switch(ue->userType)
        {
            case CR::ErrorEvent:
            case CR::LogEvent:
            {   
                TraceEvent * te = static_cast<TraceEvent *>(ue);
                if(te->userType == CR::ErrorEvent)
                {
                    error(te->msg);
                }
                else
                {
                    log(te->msg);
                }
            }
                break;
            default:
                return false;
        }
    }
    else
    {
        return QTcpServer::event(event);
    }
    return true;
}

现在如果编译程序我得到这个错误:

g++ -c -pipe -O2 -Wall -W -DQT_NO_DEBUG -DQT_NETWORK_LIB -DQT_CORE_LIB -DQT_SHARED -I/usr/local/share/qt4/mkspecs/freebsd-g++ -I. -I/usr/local/include/qt4/QtCore -I/usr/local/include/qt4/QtNetwork -I/usr/local/include/qt4 -I. -I/usr/local/include/qt4 -I/usr/local/include -o chatserver.o chatserver.cpp
g++ -c -pipe -O2 …

我为以下代码得到了非常奇怪的时间:

import numpy as np
s = 0
for i in range(10000000):
    s += np.float64(1) # replace with np.float32 and built-in float

• 内置浮子:4.9秒
• float64:10.5 s
• float32:45.0 s

为什么float64比两倍慢float？为什么float32比float64慢5倍？

有没有办法避免使用的惩罚np.float64,并有numpy功能返回内置float而不是float64？

我发现使用numpy.float64比Python的浮点慢得多,numpy.float32甚至更慢(即使我在32位机器上).

numpy.float32在我的32位机器上.因此,每次我使用各种numpy函数时numpy.random.uniform,我将结果转换为float32(以便以32位精度执行进一步的操作).

有没有办法在程序或命令行中的某处设置单个变量,并使所有numpy函数返回float32而不是float64？

编辑#1:

在算术计算中,numpy.float64 比浮点慢10倍.它非常糟糕,甚至在计算之前转换为浮动和返回使程序运行速度提高了3倍.为什么？我能做些什么来解决它吗？

我想强调一下,我的时间安排不是由以下任何原因引起的:

• 函数调用
• numpy和python float之间的转换
• 对象的创建

我更新了我的代码,以便更清楚地解决问题所在.使用新代码,我发现使用numpy数据类型可以看到十倍的性能:

from datetime import datetime
import numpy as np

START_TIME = …

HTTP/1.1 Accept请求标头在RFC 2616的第14.1节中指定.

它的语法是这样的:

   Accept         = "Accept" ":"
                    #( media-range [ accept-params ] )

#根据第2.1节,没有任何数字状态为零或更多.但是,第14.1节没有说明如何解释空标题.这与第14.2节相反,第14.2节谈到了,不仅使用了(一个或多个),而且指定了空标题的情况,这有点奇怪.处理请求标头的其他一些部分也特定于空值的特殊情况.AcceptAccept-Encoding1#Accept-Encoding

是否应该将空 Accept标题等同于不存在的 Accept标题？我错过了这方面的官方资源吗？

我有这样的结构(简化的类型来承载这一点),生活在std::vector:

struct Region {
    int first;
    int count;
    struct Metadata region_metadata;
};

在向量中,它们按顺序排列first.如果添加first和count,你得到的first下一个区域的; 所以基本上这个结构向量描述了连续数字范围的元数据.

现在给出一个整数,我想查找元数据.由于区域已分类,我可以使用std::upper_bound.我这样实现了它:

struct Comp
{
    inline bool operator()(const Region &region, int index) const
    {
        return region.first < index;
    }

    inline bool operator()(int index, const Region &region) const
    {
        return index < region.first;
    }
};

调用时std::upper_bound,这有效:

auto iter = std::upper_bound(m_regions.begin(),
                             m_regions.end(),
                             index,
                             Comp());

现在,这种情况发生的工作,因为upper_bound可以在内部挑选相匹配的要求,超载,因为它同时呼吁Comp()(Region, int)和Comp()(int, Region)(这就是为什么一个原因[](const Region …

我试图确保函数参数是异步函数。所以我在玩以下代码：

async def test(*args, **kwargs):
    pass

def consumer(function_: Optional[Coroutine[Any, Any, Any]]=None):
    func = function_

consumer(test)

但它不起作用。

在 pyCharm 中进行类型检查时出现以下错误：

Expected type 'Optional[Coroutine]', got '(args: Tuple[Any, ...], kwargs: Dict[str, Any]) -> Coroutine[Any, Any, None]' instead

谁能给我一些提示如何解决这个问题？

所以我正在读这篇关于类型擦除的文章.但该文章中的代码似乎部分不正确,例如:

template <typename T>
class AnimalWrapper : public MyAnimal
{
    const T &m_animal;

public:
    AnimalWrapper(const T &animal)
        : m_animal(animal)
    { }

    const char *see() const { return m_animal.see(); }
    const char *say() const { return m_animal.say(); }
};

其次是

void pullTheString()
{
    MyAnimal *animals[] = 
    {
        new AnimalWrapper(Cow()), /* oO , isn't template argument missing? */
        ....
    };
}

这些错误使我不鼓励在文章中进一步阅读.

无论如何; 有没有人可以用简单的例子教C++中哪种类型的擦除？

我想了解它是如何std::function工作的,但无法理解它.

我正在使用一个具有示例应用程序的库.样本makefile包含$<在参数中:

all:test.cpp
    g++ -Wl,--no-as-needed -o Example $<
clean:
    rm -f SampleApp11

我看了这个,教程点说

$ <导致操作的相关文件的名称.

另一个网站指出:

这是从.c构建.o的后缀替换规则,它使用自动变量$ <:规则的先决条件的名称(.c文件)和$ @:规则的目标名称(.o.文件)(参见关于自动变量的gnu make manual部分).co:$(CC)$(CFLAGS)$(INCLUDES)-c $ <-o $ @

我仍然感到困惑,这意味着什么？

我试图num1**num2在Python中计算一些.但问题是,num1是93192289535368032L和num2是84585482668812077L,这是非常大的数字.

我尝试了几种方法如下:首先,我尝试使用**运算符来计算它.但是花了太多时间(我等了大约2个小时,但没有结果).

第二,我用过math.pow(num1, num2).但我得到了这个:

Traceback (most recent call last):   File "<pyshell#23>", line 1, in <module>
    math.pow(84585482668812077L, 93192289535368032L)
OverflowError: math range error

最后,我使用了numpy.power:

numpy.power(84585482668812077, 93192289535368032)
-9223372036854775808

如你所见,它给了我减去.

我真正想做的就是result = (num1**num2)然后result % num3.所以,我需要有效地计算这个功率值.

我怎样才能做到这一点？

我正在使用pyLR1编写自定义描述语言的词法规则,其中包括时间文字,例如:

10h30m     # meaning 10 hours + 30 minutes
5m30s      # meaning 5 minutes + 30 seconds
10h20m15s  # meaning 10 hours + 20 minutes + 15 seconds
15.6s      # meaning 15.6 seconds

规范的小时,分钟和第二部分的次序应固定h,m,s.为了详细说明这一点,我想下面的有效组合hms,hm,h,ms,m和s(当然不同阶层之间的数字).作为奖励,正则表达式应该检查段中的十进制(即非自然)数字,并且仅在具有最小重要性的段中允许这些数字.

所以除了最后一组之外我还有一个数字匹配:

([0-9]+)

对于最后一组甚至:

([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)  # to allow for .5 and 0.5 and 5.0 and 5

通过h,m和sa的所有组合,可爱的小蟒蛇脚本给了我以下正则表达式:

(([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)h|([0-9]+)h([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)m|([0-9]+)h([0-9]+)m([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)s|([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)m|([0-9]+)m([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)s|([0-9]*\.[0-9]+|[0-9]+(\.[0-9]*)?)s) 

显然,这是一个有点恐怖的表达.有什么方法可以简化这个吗？答案必须与pythons re模块一起使用,我也会接受pyLR1由于其正则表达式的受限子集而无法使用的答案.