小编Rap*_*ael的帖子

为什么 np.dot 比 np.sum 快这么多？根据这个答案，我们知道 np.sum 很慢并且有更快的替代方案。

例如：

In [20]: A = np.random.rand(1000)\n\nIn [21]: B = np.random.rand(1000)\n\nIn [22]: %timeit np.sum(A)\n3.21 \xc2\xb5s \xc2\xb1 270 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 100,000 loops each)\n\nIn [23]: %timeit A.sum()\n1.7 \xc2\xb5s \xc2\xb1 11.5 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 1,000,000 loops each)\n\nIn [24]: %timeit np.add.reduce(A)\n1.61 \xc2\xb5s \xc2\xb1 19.6 ns per loop (mean \xc2\xb1 std. dev. of 7 runs, 1,000,000 loops each)\n

但它们都比以下慢： …

我在RHEL机器上从源安装了python-igraph 0.5.4和igraph 0.5.4(也测试了0.6).一切都很好,除非我试图策划我得到.

"TypeError:绘图不可用"

配置或安装阶段没有错误或警告.

我需要在linux上安装什么才能使绘图工作？我没有root,所以需要从源代码安装它.

甲托普利兹矩阵"是一个矩阵,其中每个对角降序从左至右是恒定的." 给定二进制矩阵M,是否有一种有效的算法来确定是否存在使其成为Toeplitz的行的排列？

例如,设置

M= [0 1 1]
   [1 1 0]
   [1 0 1]

如果你交换了第一行和第二行

[1 1 0]
[0 1 1]
[1 0 1]

这是Toeplitz.

在python中,您可以创建一个随机二进制矩阵,如下所示.

n = 10
h = 10
M =  np.random.randint(2, size=(h,n))

我想将测试应用于M.

(注意矩阵M不需要是正方形.)

Mojo 是一种编程语言，据称比 Python 快 65000 倍。我很想知道是否有任何具体的基准数据支持这一说法？另外，它在现实世界的问题中有何不同？

我主要是在他们的网站上遇到这种说法，并且观看了几个讨论 Mojo 速度的视频。然而，我正在寻找证实这一主张的具体基准数据。

这是一个流行的,高度赞成的Create pdf的蟒蛇副本,带有R中的工具提示.

简单的问题:有没有办法在PDF文件中绘制python中的图形并包含工具提示？

考虑以下丢番图方程示例

-118w + 989x + 918y  -512z == 0

您可以通过以下方式解决此问题：

import sympy
from sympy.solvers.diophantine import diophantine 
w, x, y, z = sympy.symbols('w x y z')
a, b, c, d = -118, 989, 918, -512
diof = list(diophantine(a*w + b*x +c*y +d*z ))[0]
print(diof)

这使：

(t_0, 118*t_0 + 2*t_1, 1690468*t_0 + 28937*t_1 + 256*t_2, 3031184*t_0 + 51887*t_1 + 459*t_2)

说明：该解决方案允许您自由选择三个整数 t_0、t_1、t_2，然后您可以计算 w、x、y、z 的值。

这很好，只是系数总是比需要的大得多。如果您在 Mathematica 中求解同一系统，您将得到：

x = 2 c_2, y = 9 c_2 + 256 c_3 + 81 w, z …

这个编码问题源自这个问题。

考虑一个 n × n 的整数网格。任务是在网格上画一条直线，使包含左上角的部分之和达到尽可能大的数字。这是得分为 45 的最佳解决方案的图片：

如果其中间位于线上或线上，则我们在要求和的部分中包含一个正方形。上面是指包括网格左上角的部分。（为了使这个定义更清楚，任何线都不能完全从网格的左上角开始。）

任务是选择一条线，使包含左上角正方形的部分的总和最大化。该线必须从一侧直线到另一侧。该线可以在一侧的任何位置开始或结束，而不仅仅是在整数点处。

给出的Python代码是：

import numpy as np
import fractions

def best_line(grid):
    n, m = grid.shape
    D = [(di, dj) for di in range(-(n - 1), n) for dj in range(-(n - 1), n)]
    def slope(d):
        di, dj = d
        if dj == 0:
            return float('inf') if di <= 0 else float('-inf'), -di
        else:
            return fractions.Fraction(di, dj), fractions.Fraction(-1, dj)
    D.sort(key=slope)
    D = np.array(D, dtype=np.int64)
    s_max = grid.sum()
    for grid in (grid, …

我想按照整数对的绝对值之和的顺序迭代整数对。该列表应如下所示：

(0,0)
(-1,0)
(0,1)
(0,-1)
(1,0)
(-2,0)
(-1,1)
(-1,-1)
(0,2)
(0,-2)
(1,1)
(1,-1)
(2,0)
[...]

对于具有相同绝对值总和的对，我不介意它们的顺序。

理想情况下，我希望能够永远创建这些对，以便我可以依次使用每一对。你怎么能这么做呢？

对于固定范围，我可以用一种丑陋的方式制作对列表：

sorted([(x,y)for x in range(-20,21)for y in range(-20,21)if abs(x)+abs(y)<21],key=lambda x:sum(map(abs,x))

这不允许我永远迭代，也不允许一次给我一对。

我有这个简单的 python/numba 代码：

from numba import njit\nimport numba as nb\n@nb.njit(nb.uint64(nb.uint64))\ndef popcount(x): \n      b=0\n      while(x > 0):\n          x &= x - nb.uint64(1)   \n          b+=1\n      return b\n@njit\ndef timed_loop(n):\n    summand = 0\n    for i in range(n):\n        summand += popcount(i)\n    return summand\n

它只是将整数 0 到 n - 1 的 popcount 相加。

当我计时时，我得到：

%timeit timed_loop(1000000)\n340 \xc2\xb5s \xc2\xb1 1.08 \xc2\xb5s per loop (mean \xc2\xb1 std. dev. of 7 runs, 1,000 loops each)\n

事实证明，llvm 巧妙地将 popcount 函数转换为本机 CPU POPCNT 指令，因此我们应该期望它很快。但问题是，速度有多快。 …

我有这个代码：

from collections import Counter
import numpy as np

def make_data(N):
    np.random.seed(40)
    g = np.random.randint(-3, 4, (N, N))
    return g


N = 100
g = make_data(N)
n = g.shape[0]

sum_dist = Counter()
for i in range(n):
    for j in range(n):
        dist = i**2 + j**2
        sum_dist[dist] += g[i, j]

sorted_dists = sorted(sum_dist.keys())
for i in range(1, len(sorted_dists)):
    sum_dist[sorted_dists[i]] += sum_dist[sorted_dists[i-1]]

# print(sum_dist)
print(max(sum_dist, key=sum_dist.get))

输出为 7921。

我想将其转换为仅 numpy 代码并摆脱 Counter。我怎样才能做到这一点？