小编ele*_*ora的帖子

[与2013年9月27日https://codegolf.stackexchange.com/questions/12664/implement-superoptimizer-for-addition相关]

我对如何编写超级优化器感兴趣.特别是找到比特和的小逻辑公式.之前这是对codegolf的挑战,但它似乎比人们想象的要困难得多.

我想编写代码,找到最小可能的命题逻辑公式,以检查y二进制0/1变量的总和是否等于某个值x.让我们调用变量x1,x2,x3,x4等.在最简单的方法中,逻辑公式应该等于和.也就是说,当且仅当和等于x时,逻辑公式才应该为真.

这是一种天真的方式.假设y = 15且x = 5.选择所有3003种不同的方式来选择5个变量,并为每个变量创建一个带有这些变量的AND的新子句和剩余变量否定的AND.你最终会得到3003个条款,每个条款的长度恰好为15个,总费用为45054.

但是,如果允许您在解决方案中引入新变量,那么通过消除常见的子公式可以大大减少这一点.所以在这种情况下,你的逻辑公式由y二元变量x和一些新变量组成.当且仅当y变量的总和等于x时,整个公式才是可满足的.唯一允许的运营商是and,or和not.

事实证明,当x = 1时,有一种解决这个问题的聪明方法,至少在理论上是这样.但是,我正在寻找一种计算密集型方法来搜索小型解决方案.

How can you make a superoptimizer for this problem?

例子.举两个变量作为一个例子,我们想要一个逻辑公式,当它们总和为1时就是True.一个可能的答案是:

(((not y0) and (y1)) or ((y0) and (not y1)))

为了引入新的变量成式如z0以表示y0 and not y1那么我们可以引入新的条款 (y0 and not y1) or not z0和更换y0 and not y1通过z0贯穿式的其余部分.当然,在这个例子中这是没有意义的,因为它使表达更长.

我有一个numpy数组A.我希望以非A有效的方式返回非零之前的零数,因为它处于循环中.

如果A = np.array([0,1,2])然后np.nonzero(A)[0][0]返回1.但是如果A = np.array([0,0,0])这不起作用(在这种情况下我想要答案3).而且如果A非常大并且第一个非零值接近开头,这似乎效率低下.

我试图从python中的http://jheusser.github.io/2013/09/08/hawkes.html重现这项工作,除了不同的数据.我编写了代码来模拟泊松过程以及他们描述的霍克斯过程.

为了做霍克斯模型MLE,我将对数似然函数定义为

def loglikelihood(params, data):
    (mu, alpha, beta) = params
    tlist = np.array(data)
    r = np.zeros(len(tlist))
    for i in xrange(1,len(tlist)):
        r[i] = math.exp(-beta*(tlist[i]-tlist[i-1]))*(1+r[i-1])
    loglik  = -tlist[-1]*mu
    loglik = loglik+alpha/beta*sum(np.exp(-beta*(tlist[-1]-tlist))-1)
    loglik = loglik+np.sum(np.log(mu+alpha*r))
    return -loglik

使用一些虚拟数据,我们可以计算Hawkes过程的MLE

atimes=[58.98353497,   59.28420225,   59.71571013,   60.06750179,   61.24794134,
61.70692463,   61.73611983,   62.28593814,   62.51691723,   63.17370423
,63.20125152,   65.34092403,  214.24934446,  217.0390236,   312.18830525,
319.38385604,  320.31758188,  323.50201334,  323.76801537,  323.9417007]

res = minimize(loglikelihood, (0.01, 0.1,0.1),method='Nelder-Mead',args = (atimes,))
print res

但是,我不知道如何在python中执行以下操作.

1. 我怎样才能获得相同的evalCIF来获得类似的拟合与经验强度图？
2. 如何计算Hawkes模型的残差,使其等效于他们拥有的QQ图.他们说他们使用一个名为ptproc的R包但我找不到python等价物.

自Unix时代开始以来,我有几秒钟的时间.我想用24小时制作它们.到目前为止我的努力是

from __future__ import division
import matplotlib.pyplot as plt
import numpy as np
angles = 2*np.pi*np.random.randint(0,864000,100)/86400
ax = plt.subplot(111, polar=True)
ax.scatter(angles, np.ones(100)*1)
plt.show()

这给出了以下内容

但是,这并不是我想要的.

• 如何将圆点放在圆周上而不是放在内部(或至少将它们从中心向外移动)？
• 如何将标签从角度更改为时间？
• 我怎么能摆脱0.2, 0.4, ...？
• 基本上,我怎样才能让它看起来更像是时钟上标记的点？

在 numpy 中，是否有一种很好的惯用方法来测试二维数组中的所有行是否不同？

我以为我能做到

len(np.unique(arr)) == len(arr)

但这根本不起作用。例如，

arr = np.array([[1,2,3],[1,2,4]])
np.unique(arr)
Out[4]: array([1, 2, 3, 4])

p字符串的句点w是任何正整数p,以便w[i]=w[i+p] 每当定义该等式的两侧时.让我们来per(w)表示最小周期的大小w.我们说字符串w是周期性的iff per(w) <= |w|/2.

因此,非正式地,周期性字符串只是一个由重复至少两次的前缀组成的字符串.唯一的复杂因素是在字符串的末尾我们不需要前缀的完整副本.

例如,考虑字符串x = abcab.per(abcab) = 3as x[1] = x[1+3] = a,x[2]=x[2+3] = b并没有更小的时期.abcab因此,字符串不是周期性的.但是,字符串ababa是周期性的per(ababa) = 2.

随着越来越多的例子abcabca,ababababa并且abcabcabc也是周期性的.

是否有正则表达式来确定字符串是否是周期性的？

我真的不介意哪种正则表达式,但如果它有所作为,Python re支持的任何东西.

我有一个大的csv,每行有两个字符串:

g,k
a,h
c,i
j,e
d,i
i,h
b,b
d,d
i,a
d,h

我在前两列中读取并将字符串重新编码为整数,如下所示:

import pandas as pd
df = pd.read_csv("test.csv", usecols=[0,1], prefix="ID_", header=None)
from sklearn.preprocessing import LabelEncoder

# Initialize the LabelEncoder.
le = LabelEncoder()
le.fit(df.values.flat)

# Convert to digits.
df = df.apply(le.transform)

此代码来自/sf/answers/2759353971/.

代码工作得很好,但是当df很大时代码很慢.我计划每一步,结果令我感到惊讶.

• pd.read_csv 大约需要40秒.
• le.fit(df.values.flat) 大约需要30秒
• df = df.apply(le.transform) 大约需要250秒.

有没有办法加快这最后一步？感觉它应该是他们所有人中最快的一步!

在具有4GB RAM的计算机上进行重新编码步骤的更多时间

maxymoo下面的答案很快,但没有给出正确的答案.以问题顶部的示例csv为例,将其转换为:

   0  1
0  4  6
1  0  4
2  2  5
3  6  3
4  3  5
5  5  4
6  1  1 …

我第一次使用cython来获得某个功能的速度.该函数采用方矩阵A浮点数并输出单个浮点数.它正在计算的功能是矩阵的永久性

当A为30乘30时,我的代码目前在我的电脑上占用大约60秒.

在下面的代码中,我从维基页面实现了永久性的Balasubramanian-Bax/Franklin-Glynn公式.我打电话给矩阵M.

代码的一个复杂部分是数组f,其用于保持在数组d中翻转的下一个位置的索引.数组d包含+ -1的值.循环中对f和j的操作只是一种快速更新格雷码的巧妙方法.

from __future__ import division
import numpy as np
cimport numpy as np
cimport cython


DTYPE_int = np.int
ctypedef np.int_t DTYPE_int_t
DTYPE_float = np.float64
ctypedef np.float64_t DTYPE_float_t

@cython.boundscheck(False) # turn off bounds-checking for entire function
@cython.wraparound(False)  # turn off negative index wrapping for entire function
def permfunc(np.ndarray [DTYPE_float_t, ndim =2, mode='c'] M):
    cdef int n = M.shape[0]
    cdef np.ndarray[DTYPE_float_t, ndim =1, mode='c' ] d = np.ones(n, dtype=DTYPE_float)
    cdef int j = …

我想实现以下算法.对于n和k,考虑所有重复排序的组合,我们k从{0,..n-1}重复中选择数字.例如,如果n=5和k =3我们有:

[(0,0,0),(0,0,1),(0,0,2),(0,0,3),(0,0,4),(0,1,1),( 0,1,2),(0,1,3),(0,1,4),(0,2,2),(0,2,3),(0,2,4),(0, 3,3),(0,3,4),(0,4,4),(1,1,1),(1,1,2),(1,1,3),(1,1, 4),(1,2,2),(1,2,3),(1,2,4),(1,3,3),(1,3,4),(1,4,4) ,(2,2,2),(2,2,3),(2,2,4),(2,3,3),(2,3,4),(2,4,4),( 3,3,3),(3,3,4),(3,4,4),(4,4,4)]

从现在开始,我将把每个组合视为一个多重组合.我想贪婪地浏览这些多字节并对列表进行分区.分区具有属性,其中所有多个集合的交集大小必须至少为k-1.所以在这种情况下我们有:

(0, 0, 0), (0, 0, 1), (0, 0, 2), (0, 0, 3), (0, 0, 4)

然后

 (0, 1, 1), (0, 1, 2), (0, 1, 3), (0, 1, 4)

然后

(0, 2, 2), (0, 2, 3), (0, 2, 4)

然后

(0, 3,  3), (0, 3, 4)

然后

(0, 4, 4)

等等.

在python中,您可以按如下方式迭代组合:

import itertools
for multiset in itertools.combinations_with_replacement(range(5),3): …

我想为将在 gcc 中编译的 C 代码指定编译器选项。由于代码的部署方式，我需要在代码中执行此操作。这是当前似乎成功指定优化标志的代码。

#pragma GCC optimize ("-O3,-ffast-math")
typedef float v4sf __attribute__ ((vector_size (16)));
typedef union {
  v4sf v;
  float e[4];
} float4;
typedef struct {
  float4 x;
  float4 y;
} complex4;
static complex4 complex4_mul(complex4 a, complex4 b) {
  return (complex4){a.x.v*b.x.v -a.y.v*b.y.v, a.y.v*b.x.v + a.x.v*b.y.v};
}
complex4 f4(complex4 x[], int n) {
  v4sf one = {1,1,1,1};
  complex4 p = {one,one};
  for (int i = 0; i < n; i++) p = complex4_mul(p, x[i]);
  return p;
}

但是，我也想指定-march=native. …