小编uho*_*hoh的帖子

这里scipy.integrate.odeint用六个不同的标准颂歌问题来调用rtol= atolfrom 1E-06to 1E-13。我查看了所有较大公差的结果之间的最大差异减去最小公差的结果，以获得某种“错误”的表示。我很好奇为什么对于给定的容差，一个问题 (D5) 给出的错误比另一个问题 (C1) 严重一百万倍，即使步数范围相当窄（在 10 倍之内）。

脚本中给出了颂歌问题的引用。所有问题都相当正常化，所以我正在进行rtol类似的治疗atol。

重申一下 - 我的问题是，为什么不同问题之间的误差几乎相差一个因子1E+06，尽管误差随容差而变化。当然，C1 是“最柔和的”，D5 在“近日点”处具有戏剧性的峰值，但我认为例程会在内部调整步长，以便误差相似。

编辑：我添加了“错误”的时间演变，这可能会带来一些启发。

# FROM: "Comparing Numerical Methods for Ordinary Differential Equations"
# T.E. Hull, W.H. Enright, B.M. Fellen and A.E. Sedgwidh
# SIAM J. Numer. Anal. vol 9, no 4, December 1972, pp: 603-637

def deriv_B1(y, x):
    return [2.*(y[0]-y[0]*y[1]), -(y[1]-y[0]*y[1])] # "growth of two conflicting populations"

def deriv_B4(y, x):
    A = …

更新： Skyfield 刚刚进行了重大修订，包括扩展文档和角度分离方法 - 请参阅已接受的答案。

我正在使用Skyfield计算两个物体之间的表观角距。我没有在包中找到方法，所以我“发明”了一种通过计算两个视位置向量之间的点积的方法。

这是目前最好的方法吗？在Skyfield的范围内，它本质上是正确的吗？

def separation(seconds, lat, lon):

    lat, lon, seconds = float(lat), float(lon), float(seconds) # necessary it seems

    place = earth.topos(lat, lon)

    jd = JulianDate(utc=(2016, 3, 9, 0, 0, seconds))

    mpos = place.at(jd).observe(moon).apparent().position.km
    spos = place.at(jd).observe(sun).apparent().position.km

    mlen = np.sqrt((mpos**2).sum())
    slen = np.sqrt((spos**2).sum())

    sepa = ((3600.*180./np.pi) *
            np.arccos(np.dot(mpos, spos)/(mlen*slen)))

    return sepa


from skyfield.api import load, now, JulianDate
import numpy as np
from scipy.optimize import minimize

data = load('de421.bsp')

sun   = data['sun']
earth = data['earth']
moon  = …

下面的脚本是抽象的。我的问题是关于使用threading.Lock()

锁定限制了对“共享资源”的访问，但我对这能走多远感到紧张。我有对象属性，它们是在这个例子中具有数组属性的对象列表。在某些情况下，依赖会走得更远。

是否Lock()“知道”需要锁定的所有内容？

还显示了下面脚本的输出。脚本的目的主要是为了讨论 - 它不会失败，但我不相信它会锁定它需要的一切。

start:   [array([0, 1]), array([0, 1, 2]), array([0, 1, 2, 3])]
append an object
done!
finish:  [array([505, 605]), array([10, 11, 12]), array([10, 11, 12, 13]), array([5])]


import time
from threading import Thread, Lock
import numpy as np

class Bucket(object):
    def __init__(self, objects):
        self.objects = objects

class Object(object):
    def __init__(self, array):
        self.array = array

class A(Thread):
    def __init__(self, bucket):
        Thread.__init__(self)
        self.bucket      = bucket
    def run(self):
        nloop            = 0
        locker …

我确定我遗漏了一些明显的东西。我通过内容文件夹内的文件夹名称定义类别。如果我content在查看页面时单击，我会看到文件夹名称（例如，categ1、categ2）加上“misc”，这很好。当我单击 categ1 时，我会看到一篇完整的文章，但图像链接现在都已损坏。

localhost:8000/category/categ1.html

我希望看到的只是该类别中可点击的文章列表。或者至少，没有断开的链接。

（如果我尝试使用标签，我有类似的行为，但一次只做一件事......）

.rst文件中没有类别行。

除了名称、时区等。我在我的配置中使用这些。

更新：图像位于内容的图像文件夹中。我还在categ1 中放了一个Images 文件夹的副本，但没有帮助。

THEME = 'nmnlist' 

PATH = 'content'

# ARTICLE_PATHS = ['articles']    # have tried this also

STATIC_PATHS = ['images', 'pdfs']

RELATIVE_URLS = True  # have tried False also

PLUGINS = ["render_math"]

scipy.optimize.minimize使用默认方法将返回初始值作为结果，而不会出现任何错误或警告消息。在使用此答案建议的Nelder-Mead方法解决问题时，我想了解：

为什么默认方法会在不警告起点的情况下返回错误答案作为答案-并且 在这种情况下，有什么方法可以防止“没有警告就错误回答”避免这种情况？

请注意，该函数separation使用python软件包Skyfield生成无法保证平滑的最小化值，这可能就是为什么Simplex在此处更好的原因。

结果：

测试结果：[ 2.14159739 ]'正确'： 2.14159265359初始值：0.0

默认结果：[ 10000。 ]“正确”：13054初始值： 10000

Nelder-Mead结果：[ 13053.81011963 ]'正确'： 13054初始值：10000

FULL OUTPUT using DEFAULT METHOD:
   status: 0
  success: True
     njev: 1
     nfev: 3
 hess_inv: array([[1]])
      fun: 1694.98753895812
        x: array([ 10000.])
  message: 'Optimization terminated successfully.'
      jac: array([ 0.])
      nit: 0

FULL OUTPUT using Nelder-Mead METHOD:
  status: 0
    nfev: 63
 success: True
     fun: 3.2179306044608054
       x: array([ 13053.81011963])
 message: 'Optimization terminated …

使用 numpy\'s Zeros_like和相关函数，有一个选项

\n

subok：布尔值，可选。

\n

numpy.zeros_like(a, dtype=None, order=\'K\', subok=True)

\n

如果为True，则新创建的数组将使用\xe2\x80\x98a\xe2\x80\x99的子类类型，否则为基类数组。默认为 True。

\n

我假设所有 numpy 数组都是类ndarray，并且我从来不需要详细查看数组的子类。在什么情况下我可能想选择不使用相同的子类，而指定使用基类？

使用 PIL 读取图像后，我通常使用 scipy.ndimage 执行高斯滤波器，如下所示

import PIL
from scipy import ndimage

PIL_image = PIL.Image.open(filename)
data = PIL_image.getdata()
array = np.array(list(data)).reshape(data.size[::-1]+(-1,))
img = array.astype(float)
fimg = ndimage.gaussian_filter(img, sigma=sigma, mode='mirror', order=0)

PIL 中有如下高斯模糊函数（来自这个答案），但我不知道它究竟是如何工作的，也不知道它使用的是什么内核：

from PIL import ImageFilter
fimgPIL = PIL_image.filter(ImageFilter.GaussianBlur(radius=r)

本文档不提供详细信息。

关于的问题PIL.ImageFilter.GaussianBlur：