小编ead*_*ead的帖子

到目前为止,我能够获取当前的语言环境,但我想获取该特定语言环境的日期格式.可以使用标准库完成此操作.

#include <locale>

int _tmain(int argc, _TCHAR* argv[])
{
   // Print the current locale
    std::cout << std::locale("").name().c_str() << "\n";

    // TODO: get the locale's date pattern, example for US it's (mm/dd/yyyy)
    std::cout << "date pattern:  \n";
}

我有一群人,他们每个人都有朋友名单和敌人名单.我想把它们排成一行(桌子上没有圆圈),所以没有敌人,只有朋友彼此相邻.

输入示例:https://gist.github.com/solars/53a132e34688cc5f396c

我想我需要使用图形着色来解决这个问题,但我不确定如何 - 我想我必须省略朋友(或敌人)列表以使其更容易并映射到图表.

有谁知道如何解决这些问题,并告诉我,如果我走在正确的道路上？

代码示例或在线示例也不错,我不介意编程语言,我通常使用Ruby,Java,Python,Javascript

非常感谢你的帮助!

IEEE 754标准的结果之一是std::unordered_set<double>当NAN插入非数字元素时的非直观行为.

由于事实NAN!=NAN,在以下顺序之后:

#include <iostream>
#include <cmath>
#include <unordered_set>

int main(){
    std::unordered_set<double> set;
    set.insert(NAN);
    set.insert(NAN);
    std::cout<<"Number of elements "<<set.size()<<"\n";  //there are 2 elements!
}

有两个元素set(见它直播):NAN和NAN!

我的主要问题是,当N NANs被插入到散列集中时,它们都会击中相同的散列桶,并且N插入到散列集中的性能会退化为最坏情况下的运行时间 - O(N^2).

例如,请参阅问题末尾的列表或此处实时插入NAN比"正常"浮点数花费的时间多一些数量级.

我的问题:是否有可能(如果是 - 如何)以std::unordered_set<double>这种方式进行调整NAN,无论插入的NANs(NAN, - NAN等等)的风格如何,集合中最多只有一个元素？

清单:

#include <iostream>
#include <cmath>
#include <unordered_set>
#include <chrono>

constexpr int N=5000;
void …

编译时

double isnan(double x){
   return x!=x
}

既铛和gcc利用奇偶标志PF:

_Z6is_nand: # @_Z6is_nand
  ucomisd %xmm0, %xmm0
  setp %al
  retq

然而,这两个可能的结果比较如下:

      NaN     Not-Nan
ZF     1        1
PF     1        0
CF     1        0

这意味着也可以使用CF-flag作为替代,即setb代替setp.

是否有使用任何优势setp了setb,或者是一个巧合,这两个编译器使用奇偶标志？

PS:这个问题是了解std :: isnan的编译结果

通常我可以在使用 Cython 时匹配 Numba 的性能。然而，在这个例子中我没有这样做 - Numba 比我的 Cython 版本快大约 4 倍。

这里是 Cython 版本：

%%cython -c=-march=native -c=-O3
cimport numpy as np
import numpy as np
cimport cython

@cython.boundscheck(False)
@cython.wraparound(False)
def cy_where(double[::1] df):
    cdef int i
    cdef int n = len(df)
    cdef np.ndarray[dtype=double] output = np.empty(n, dtype=np.float64)
    for i in range(n):
        if df[i]>0.5:
            output[i] = 2.0*df[i]
        else:
            output[i] = df[i]
    return output 

这是 Numba 版本：

import numba as nb
@nb.njit
def nb_where(df):
    n = len(df)
    output = np.empty(n, dtype=np.float64)
    for …

我将csv更改为npy文件.更改后,csv文件的大小为5GB,npy为13GB.我认为npy文件比csv更有效.我误解了吗？为什么npy的大小比csv大？

我刚刚用过这段代码

full = pd.read_csv('data/RGB.csv', header=None).values
np.save('data/RGB.npy', full, allow_pickle=False, fix_imports=False)

和数据结构如下:

R, G, B, is_skin
2, 5, 1, 0
10, 52, 242, 1
52, 240, 42, 0
...(row is 420,711,257)

看起来,对于Cython的cdef类,使用类特殊方法有时比相同的"常规"方法__setitem__更快,例如比setitem以下快3倍:

%%cython
cdef class CyA:
    def __setitem__(self, index, val):
        pass
    def setitem(self, index, val):
        pass

现在:

cy_a=CyA()
%timeit cy_a[0]=3              # 32.4 ns ± 0.195 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)
%timeit cy_a.setitem(0,3)      # 97.5 ns ± 0.389 ns per loop (mean ± std. dev. of 7 runs, 10000000 loops each)

这既不是Python的"正常"行为,特殊功能甚至更慢(并且比Cython等效的速度慢):

class PyA:
    def __setitem__(self, index, val):
        pass
    def setitem(self, index, val):
        pass

py_a=PyA()
%timeit py_a[0]=3           # 198 ns …

我一直假设numpy 使用一种pairwise-summation，它也确保 - 操作的高精度float32：

import numpy as np
N=17*10**6  # float32-precision no longer enough to hold the whole sum
print(np.ones((N,1),dtype=np.float32).sum(axis=0))
# [17000000.], kind of expected

但是，如果矩阵有多于一列，则看起来好像使用了不同的算法：

print(np.ones((N,2),dtype=np.float32).sum(axis=0))
# [16777216. 16777216.] the error is just to big
print(np.ones((2*N,2),dtype=np.float32).sum(axis=0))
# [16777216. 16777216.] error is bigger

可能sum只是天真地将所有值相加。一个迹象是16777216.f+1.0f=16777216.f，例如：

one = np.array([1.], np.float32)
print(np.array([16777215.], np.float32)+one)  # 16777216.
print(np.array([16777216.], np.float32)+one)  # 16777216. as well

为什么 numpy 不对多列使用成对求和，并且 numpy 是否可以强制对多列使用成对求和？

我的numpy版本是1.14.2，如果这个起作用的话。

这对输入输出流和流缓冲（很老）的文章指出，下面的代码即可：

class DerivedStreamBuf : public std::streambuf {
  // ...
};

class DerivedOutputStream : public std::ostream {
  public:
    DerivedOutputStream():
      std::ios(0), std::ostream(&dsb) {}        //1
    // ...
  private:
    DerivedStreamBuf dsb;
    // ...
};

这可能有问题，因为何时ostream构造dsb尚未初始化，因此 UB 可能是效果。对于析构函数，它可能是相反的：dsb已经被破坏并且可以在 的析构函数中使用ostream。

但是，文章认为，“C++ 标准要求父类构造函数或析构函数（ios、istream 或 ostream）不能访问流缓冲区”。

虽然析构函数的情况很简单，例如~ostream：

虚拟 ~basic_ostream(); 备注：不对 rdbuf() 执行任何操作。

构造函数不太清楚：

显式 basic_ostream(basic_streambuf<charT, traits>* sb); 效果：使用 basic_ios<charT, traits>?::?init(sb) ([basic.ios.cons]) 初始化基类子对象。

这是否意味着这是唯一可能的效果，这个标准公式是否不允许其他效果，这些效果是 的实现细节std::ostream并且可能访问 non-initialized dsb？

我的问题：该标准是否保证上述代码是可移植的，即适用于所有符合标准的实现std::ostream？

如何asm()在cython中调用C语言的内联汇编函数？我尝试了一个简单的asm("mov $eax, 0x1") or __asm__(). 它 cythonizes 很好，直到asm-call，然后给我以下错误：

NameError：名称“asm”未定义

我将我的代码编译为python setup.py build_ext --inplace && python runids.py