你这是两串数的关联性，看程序应该是 Pearson 相关系数，样本是 1 维样本，和向量有啥关系？

不是要么下要么不下，而是要么下 50 年大雨要么不下 50 年的大雨

1/50 1/50 是如果按照一年就下一场雨，要么下要么不下，就是扔一个超有偏硬币 1:49 ，扔两次，连续扔出两个正面的概率

用柏松分布的意思是，接下来的两年（单位时间内）会发生很多雨，但是其中有种大雨（ 50 年一遇，或者 1 年 1/50 遇，或者 2 年 1/25 遇）在单位时间（两年内）发生 2 次的概率

至于对向量求导，也是基本定义，一个标量场（输入向量，输出数字）的函数，f(x) = y ，x=(x1, x2...)，则 f'(x)定义为向量
(f(x1,x2,...)'x1, f(x1,x2...)'x2, f'x3, f'x4....)
如果
f(x)是一个向量场 f(x1,x2,...) = (y1,y2,...)
则 f'x 是一个二阶矩阵
y1'x1 y1'x2,...
y2'x1, y2'x2...
也就是对向量求导需要对每一项求导，所以 xTA x 对 x 求导就是一个标量场对向量求导，需要对 x 每一项分别求导，所以需要引入新的下标 k ，(xi Aij xj)'(xk)
这些属于向量微积分，张量代数的基础知识，如果你不想完整学这些，就熟悉一下 einstein summation ，kronecker delta 然后逐项手写，实在不行就写个二阶矩阵然后逐项写，熟悉一下这方面就没问题了，学完数学是 overkill 的

先熟悉 einstein summation notation 和 Kronecker delta ，写开一项一项求，然后合并就行了，举个例子：
矩阵乘法：A=Aij, x=xi
xT A = xi Aij = Aij xi
A x = Aij xj = xj Aij
AT x= Aji xj = xj Aji
比如 xTAx = xi Aij xj 对 xk 求导，根据乘法求导法则 （ f(x)g(x)' = f'g+fg') 等于 xi'(xk) Aij xj + xi Aij xj'(xk)，因为 xi'(xk) = delta_ik ，同理 xj'(xk)=delta_jk ，所以 delta_ik Aij xj + xi Aij delta_jk = Akj xj + xi Aik ，对加和标的选择是任意的（加和可以任意换序），所以 Akj xj = Aki xi ，所以原式=Aki xi + xi Aik = (Aik+Aki)xi = (A+AT)x ，如果再不能理解就写个 2 阶矩阵 a11 a12 a21 a22 和向量 x1 x2 ，自己试试

thinkpad x1c ？好像有 4k/2k ，都是集显，i7-1185G7

@acone2003 新年快乐！
会，这个是我脑残……这个方法大概就是暴力循环
for f in features:
....for val in f:
........for l, r, val
这样，使用 numpy 的索引大概是这个计算量（按大小判定）的两倍，但是 numpy 的各种操作非常快。我觉得这个问题可以通过边界问题搞定，例如 NBins = [a.min(), 0.3, ...., np.inf]，然后 vals 减掉一个值 V ，使所有的 vals 都小于 a.min()，即 vals-V < a.min()，然后替换完以后 a = a+V ，这个方法在数组大了以后会比循环快一些，小数组和循环没啥区别。

不过根据索引也许有个简单的方法，但是 binsize 如果非常不均匀可能需要非常小的 binsize ，你这个箱体 binsize=0.1 是刚好的，先令 NBins=np.array([0.3, ...7.6])，我觉得所以
a = np.asarray(a/binsize, dtype=np.int64)
然后生成新的 NBins:
nvals = np.diff(np.array(NBins/binsize, dtype=np.int64), prepend=0))
r = np.concatenate([ [val] * n for val, n in zip(vals, nvals)])
这里 r 会生成 2 个 3.5 ，52 个 7.8,...
然后处理边界
a[a<int(NBins[0]/0.1)] = len(r)
a[a>int(NBins[-1]/0.1)] = len(r)+1
r = np.append(r, left_bound_val)
r = np.append(r, right_bound_val)
然后 r[a] 就是结果。这样的计算量是最小的。不过需要注意两点，一是 NBins 里的值不总大于 0 ，二是很小 binsize 以及变化很急剧的 NBins 会导致一个巨长的数组 r ，也会很麻烦。不过这些可以通过线性变换你的样本和 NBins 一类的方法解决，就看具体情况了。

可以给 NBins 加上左边界然后用 for:
vals = [3.5, 7.8, ...]
NBins = [-np.inf, 0.3, 5.4..., np.inf]
for l, r, val in zip(NBins[:-1], NBins[1:], vals):
....a[np.logical_and(a > l, a< r)] = val

用 numpy.array (pandas.DataFrame)?
a[a<0.3] =3.5
a[np.logical_and(a < 5.4, a > 0.3)] = 7.8

@spongebobsun ipad 有蜂窝版，不过确实不能打电话收短信，但是流量卡微信是可以随时打接的吧。不过具体还是要看老人使用，如果碰到到处弹广告的应用大多数老人是真处理不好。这点苹果还是省心。

ipad 吧，省很多麻烦。老年人的话 android 产品很容易搞很多广告以及莫名其妙安装一堆 app

……能 tm 删帖就好了，我是傻逼……

对不起我还在脑残中……按照你的思路：
def test(a):
....a = a - np.diag(np.ones(a.shape[0])) # 主元不参与比较
....ind = np.sum(a >= 0.5, axis=0) # 每个节点大于 0.5 的计数
....g = a >= 0.5 # 节点对是否大于 0.5
....drops = []
....while (ind > 0).any():
........i_drop = np.argmax(ind)
........ind = ind - g[i_drop] # 剩下计数减掉被删掉的节点（大于 0.5 则-1 ，否则-0 ）
........ind[i_drop] = -1 # 每次删掉计数最大的
........drops.append(i_drop)
....ret = np.delete(a, drops, axis=0)
....ret = np.delete(ret, drops, axis=1)
....return ret, drops
这个很快。几万也行。

更正一下，这个对节点数好像是 O(N^3)，很蠢了……4000 节点需要 36s ，10000 节点应该是 560s ，2 万节点就得一小时+，几万节点的话可能还是不合适。

按照楼主的思路：
ret = a - np.diag(np.ones(a.shape[0])) # 主元不参与比较
drops = []
idx = np.arange(a.shape[0])
while (ret>=0.5).any():
....i_drop = np.argmax(np.sum(ret > 0.5, axis=0))
....drops.append(idx[i_drop])
....ret = np.delete(ret, i_drop, axis=0)
....ret = np.delete(ret, i_drop, axis=1)
....idx = np.delete(idx, i_drop)
抱歉，应该换算一下 index ，这样 drops 最后给出的就是应该被删除的元素编号，ret 最后是一个都小于 0.5 的矩阵。

按照楼主的思路：
ret = a - np.diag(np.ones(a.shape[0])) # 主元不参与比较
drops = []
while (ret>=0.5).any():
....i_drop = np.argmax(np.sum(ret > 0.5, axis=0))
....drops.append(i_drop)
....ret = np.delete(ret, i_drop, axis=0)
....ret = np.delete(ret, i_drop, axis=1)
我试了试 10000x10000 的随机数组，粗略估计一下可能需要 4000s+，但 1000x1000 还是挺快的，大约 0.5s ，也就是能容纳 10^3 的节点数，几万个节点估计还是扯淡

看你还有后续需求的样子……试试 mpi4py ？

一般就叫 Links 吧