我想使用Sphinx的autosummary扩展和模板从docstrings递归生成API文档.我想为每个模块,类,方法,属性和功能分别设置页面.但它根本检测不到我的模板.实际上,如果我只是module.rst从中删除文件_templates/autosummary/,它会像以前一样呈现整个文件.我跟着这个问题跟着这封信.如果您有兴趣,完整的存储库位于GitHub上.
编辑:它似乎确实生成了一个不同的文件,我不得不删除docs/_autosummary来读取新模板.但是,现在它生成一个带有sparse标题和description标题的文件.它没有进入{% if classes %}和{% if functions %}指令.
我的目录结构如下:
以下是目前的相关文件:
index.rst:
.. sparse documentation master file, created by
sphinx-quickstart on Fri Dec 29 20:58:03 2017.
You can adapt this file completely to your liking, but it should at least
contain the root `toctree` directive.
Welcome to sparse's documentation!
================================== …到目前为止我的代码是:
function imgg = derichefilter1(x, k, a, b, c)
osize = size(x);
x = double(x);
a = double(a);
b = double(b);
c = double(c);
k = double(k);
y1 = zeros(osize(1),osize(2));
y2 = zeros(osize(1),osize(2));
y1(:,1) = a(1)*x(:,1);
y1(:,2) = a(1)*x(:,2) + a(2)*x(:,1) + b(1)*y1(:,1);
for ii=3:osize(2)
y1(:,ii) = a(1)*x(:,ii) + a(2)*x(:,ii-1) + b(1)*y1(:,ii-1) + b(2)*y1(:,ii-2);
end
y2(:,osize(2)-1) = a(3)*x(osize(2));
for ii=(osize(2)-2):-1:1
y2(:,ii) = a(3)*x(:,ii+1) + a(4)*x(:,ii+2) + b(1)*y2(:,ii+1) + b(2)*y2(:,ii+2);
end
imgg = c*(y1+y2);
function imgg = derichefilter2(x, k, a, b, …假设我具有带有t属性的Python类型。我想创建一个“参数化的元类型”，以便进行以下工作：
class MySuperClass(type):
pass
class MySubClass(MySuperClass):
# Here is the problem -- How do I define types that contain stuff,
# independent of an object?
def __init__(self, t): # Or __getitem__
self.t = t
def __instancecheck__(self, instance):
return isinstance(instance, MySubClass) and instance.t == self.t
def __subclasscheck__(self, subclass):
return MySubClass in subclass.__mro__ and subclass.t == self.t
class MyObject(metaclass=MySubClass):
def __init__(self, t):
self.t = t
# Test code:
## Both of these, square brackets work too
assert isinstance(MyObject(0), MySubClass(0))
assert …我刚刚发现了 Numpy 结构化数组，我发现它们非常强大。我的脑海中自然而然地出现了一个问题：我到底如何创建一个 Numpy 结构标量。让我告诉你我的意思。假设我想要一个包含一些数据的结构：
import numpy as np
dtype = np.dtype([('a', np.float_), ('b', np.int_)])
ar = np.array((0.5, 1), dtype=dtype)
ar['a']
这给了我array(0.5)而不是0.5. 另一方面，如果我这样做：
import numpy as np
dtype = np.dtype([('a', np.float_), ('b', np.int_)])
ar = np.array([(0.5, 1)], dtype=dtype)
ar[0]['a']
我明白了0.5，就像我想要的那样。这意味着它ar[0]不是数组，而是标量。是否有可能以比我所描述的更优雅的方式创建结构化标量？
Cythonlibcpp模块包含 的模板priority_queue，这很棒，但有一件事除外：我无法向它传递自定义比较器（或者，至少，我不知道如何传递）。
我需要这个，因为我需要priority_queue做argsort某种而不是sort（是的，优先级队列最适合我想做的事情），而且我需要它很快。
这在 Cython 中是否可能，也许通过以自定义方式包装队列，或者根本不可能？
举个例子，假设我想vector[int[:]]以稳定的方式按其中一个元素对 a 进行排序。实际的算法要复杂得多。
我决定通过将其逐个元素添加到priority_queue. 但是，我不知道该怎么做。
我的实际操作类似于这个问题，但是我正在按int[:]特定元素合并一维元素的排序，其中原始列表也按该元素排序。
我不介意将对象转换为缓冲区/指针。
我正在尝试创建 inverse 的 Numpy 优化版本numpy.bincounts。我意识到bincounts不是一对一的，所以让我们谈谈最简单的版本。
import numpy as np
def bincounts_inverse(counts):
list = []
dtype = np.min_scalar_type(counts.shape[0] - 1)
for bin, count in enumerate(counts):
ar = np.empty(count, dtype=dtype)
ar[:] = bin
list.append(ar)
return np.concatenate(list)
这可能是我目前对 Numpy 和 Python 的了解所能得到的最好结果。当计数高且箱低时，它会非常快，但当相反情况时，它会很慢。它是渐近最优的，但可能不是你能做的最好的。
有没有更快的方法来做到这一点？
这是一个示例输入/输出。
counts = np.array([3, 1, 0, 2, 5], np.uint8)
bincounts_inverse(counts) = np.array([0, 0, 0, 1, 3, 3, 4, 4, 4, 4, 4],
dtype=np.uint8)
所以,我只选择LINQ查询中的一个元素(cars类型Car[]):
Car selectedCar = (
from x
in cars
where x.Location * direction > location * direction
orderby x.Location * direction
select x)
.FirstOrDefault();
这基本上是一个O(n log n)操作(因为orderby).我可以通过使用LINQ来降低约30%的性能,但是当它很容易成为带有循环的O(n)时,我不能将其设为O(n log n).有没有办法保留LINQ,但减少了操作的顺序？