标签: integrate

我正在使用Perforce集成两个代码行.在生成的更改列表中,有些文件被标记为已打开以进行集成,但实际上并未更改.

我应该提交这些未更改的文件还是应该还原它们？

我想还原它们,因为我不希望这些未更改的文件污染更改列表.

但是,如果我提交它们,我会感觉Perforce可能会使用这个"事实"(文件已经集成)以供将来集成.

我有一个大学项目,要求我们使用ODE和SciPy的odeint函数模拟卫星进入火星的方法.

我设法通过将二阶ODE分成两个一阶ODE来在2D中模拟它.但是我陷入时间限制,因为我的代码使用SI单位,因此在几秒钟内运行,而Python的linspace限制甚至不能模拟一个完整的轨道.

我尝试将变量和常量转换为小时和公里,但现在代码不断给出错误.

我遵循这个方法:

http://bulldog2.redlands.edu/facultyfolder/deweerd/tutorials/Tutorial-ODEs.pdf

代码是:

import numpy

import scipy

from scipy.integrate import odeint

def deriv_x(x,t):
    return array([ x[1], -55.3E10/(x[0])**2 ]) #55.3E10 is the value for G*M in km and hours

xinit = array([0,5251]) # this is the velocity for an orbit of period 24 hours

t=linspace(0,24.0,100) 

x=odeint(deriv_x, xinit, t)

def deriv_y(y,t):
    return array([ y[1], -55.3E10/(y[0])**2 ])

yinit = array([20056,0]) # this is the radius for an orbit of period 24 hours

t=linspace(0,24.0,100) 

y=odeint(deriv_y, yinit, t)

我不知道如何从PyLab复制/粘贴错误代码,所以我采取了错误的PrintScreen:

t = linspace(0.01,24.0,100)和xinit …

使用numba.jit加快了右手端计算odeint从scipy.integrate正常工作：

from scipy.integrate import ode, odeint
from numba import jit

@jit
def rhs(t, X):
    return 1

X = odeint(rhs, 0, np.linspace(0, 1, 11))

但是这样使用integrate.ode：

solver = ode(rhs)
solver.set_initial_value(0, 0)
while solver.successful() and solver.t < 1:
    solver.integrate(solver.t + 0.1)

装饰器产生以下错误@jit：

capi_return is NULL
Call-back cb_f_in_dvode__user__routines failed.
Traceback (most recent call last):
  File "sandbox/numba_cubic.py", line 15, in <module>
    solver.integrate(solver.t + 0.1)
  File "/home/pgermann/Software/anaconda3/lib/python3.4/site-packages/scipy/integrate/_ode.py", line 393, in integrate
    self.f_params, self.jac_params)
  File "/home/pgermann/Software/anaconda3/lib/python3.4/site-packages/scipy/integrate/_ode.py", line …

我正在使用循环进行一些集成integrate，但出现了一个我无法理解的错误，也无法摆脱。这是我可以提取的 MWE：

u_min = 0.06911363
u_max = 1.011011 
m = 0.06990648
s = 0.001092265
integrate(f = function(v){pnorm(v, mean = m, sd = s, lower.tail =  FALSE)}, u_min, u_max)

这会返回一个错误“积分可能发散”，这显然是错误的。我尝试稍微修改一下参数并使其正常工作，例如：

u_min <- 0.07
u_max <- 1.1
m <- 0.0699
s <- 0.00109
integrate(f = function(v){pnorm(v, mean = m, sd = s, lower.tail =  FALSE)}, u_min, u_max)

我试图查看该integrate函数，debug但它是代码的包装C。而且我也不是正交技术的专家。我看到了这篇帖子，但无法从中得到任何东西。

谢谢

我会尽力解释我的问题并提供足够的信息来展示细节.首先,粘贴错误日志(FATAL EXCEPTION: AsyncTask #1 java.lang.RuntimeException: An error occured while executing doInBackground()):

FATAL EXCEPTION: AsyncTask #1 java.lang.RuntimeException: An error occured while executing doInBackground()
                                                                                          at android.os.AsyncTask$3.done(AsyncTask.java:299)
                                                                                          at java.util.concurrent.FutureTask.finishCompletion(FutureTask.java:352)
                                                                                          at java.util.concurrent.FutureTask.setException(FutureTask.java:219)
                                                                                          at java.util.concurrent.FutureTask.run(FutureTask.java:239)
                                                                                          at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230)
                                                                                          at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080)
                                                                                          at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573)
                                                                                          at java.lang.Thread.run(Thread.java:841)
                                                                                       Caused by: java.lang.IllegalAccessError: tried to access method android.support.v4.net.ConnectivityManagerCompat.<init>:(Lcom/facebook/react/bridge/ReactApplicationContext;)V from class com.facebook.react.modules.netinfo.NetInfoModule
                                                                                          at com.facebook.react.modules.netinfo.NetInfoModule.<init>(NetInfoModule.java:55)
                                                                                          at com.facebook.react.shell.MainReactPackage.createNativeModules(MainReactPackage.java:67)
                                                                                          at com.facebook.react.ReactInstanceManagerImpl.processPackage(ReactInstanceManagerImpl.java:751)
                                                                                          at com.facebook.react.ReactInstanceManagerImpl.createReactContext(ReactInstanceManagerImpl.java:688)
                                                                                          at com.facebook.react.ReactInstanceManagerImpl.access$600(ReactInstanceManagerImpl.java:84)
                                                                                          at com.facebook.react.ReactInstanceManagerImpl$ReactContextInitAsyncTask.doInBackground(ReactInstanceManagerImpl.java:177)
                                                                                          at com.facebook.react.ReactInstanceManagerImpl$ReactContextInitAsyncTask.doInBackground(ReactInstanceManagerImpl.java:162)
                                                                                          at android.os.AsyncTask$2.call(AsyncTask.java:287)
                                                                                          at java.util.concurrent.FutureTask.run(FutureTask.java:234)
                                                                                          at android.os.AsyncTask$SerialExecutor$1.run(AsyncTask.java:230) 
                                                                                          at java.util.concurrent.ThreadPoolExecutor.runWorker(ThreadPoolExecutor.java:1080) 
                                                                                          at java.util.concurrent.ThreadPoolExecutor$Worker.run(ThreadPoolExecutor.java:573) 
                                                                                          at java.lang.Thread.run(Thread.java:841)

我的项目结构:

android依赖项:

dependencies …

我有一个 y 值列表和一个 x 值列表。我想找到这些点定义的曲线下的面积。对于具有均匀间距的 x 值，我找到了解决此问题的几个解决方案：

1）在给定一组坐标的情况下计算曲线下的面积，而不知道函数

2）使用scipy对样本进行离散积分

但当 x 值间隔不均匀时，这两种方法都不起作用。

例如：

>>> from scipy.integrate import simps
>>> y = np.array([1,1,1,1])
>>> x = np.array([0,5,20,30])
>>> simps(y,x)
-inf

当然，在上面的代码中使用 x = np.array([0,10,20,30]) 返回 30.0，正如预期的那样。

谁能建议一种方法来找到 x 间距不均匀的曲线下的面积？

我在 python 中有一个函数（也使用 scipy 和 numpy）定义为

import numpy as np
from scipy import integrate
LCDMf = lambda x: 1.0/np.sqrt(0.3*(1+x)**3+0.7)

我想将它从 0 整合到 numpy 数组中的每个元素z = np.arange(0,100)

我知道我可以为每个元素编写一个循环，像这样迭代

an=integrate.quad(LCDMf,0,z[i])

但是，我想知道是否有一种更快、更有效（更简单）的方法来对每个 numpy 元素执行此操作。

我有以下问题：我想整合一个二维数组，所以基本上是反转一个梯度算子。

假设我有一个非常简单的数组，如下所示：

shape = (60, 60)
sampling = 1
k_mesh = np.meshgrid(np.fft.fftfreq(shape[0], sampling), np.fft.fftfreq(shape[1], sampling))

然后我将我的向量场构造为一个复值数组（x 向量 = 实部，y 向量 = 虚部）：

k = k_mesh[0] + 1j * k_mesh[1]

所以例如真实的部分看起来像这样

现在我取梯度：

k_grad = np.gradient(k, sampling)

然后我使用傅立叶变换来反转它，使用以下函数：

def freq_array(shape, sampling):

    f_freq_1d_y = np.fft.fftfreq(shape[0], sampling[0])
    f_freq_1d_x = np.fft.fftfreq(shape[1], sampling[1])
    f_freq_mesh = np.meshgrid(f_freq_1d_x, f_freq_1d_y)
    f_freq = np.hypot(f_freq_mesh[0], f_freq_mesh[1])

    return f_freq


def int_2d_fourier(arr, sampling):
    freqs = freq_array(arr.shape, sampling)

    k_sq = np.where(freqs != 0, freqs**2, 0.0001)
    k = np.meshgrid(np.fft.fftfreq(arr.shape[0], sampling), np.fft.fftfreq(arr.shape[1], sampling))

    v_int_x = np.real(np.fft.ifft2((np.fft.fft2(arr[1]) …

我想在我的 React Native 应用程序中使用动态资产交付。但我不知道如何在本机反应中使用它。请帮我！

我有一个想要集成的函数：

def f(z, t, q):
    return t * 0.5 * (erf((t - z) / 3) - 1) * j0(q * t) * np.exp(-0.5 * ((z - 40) / 2) ** 2)

我以这个函数为例来理解和展示不同集成方法之间的区别。根据通过该平台上的各种答案以及文档中获得的早期知识，我尝试了不同的方法来提高该功能的集成速度。我将在这里简要解释和比较它们：

1. 仅使用 python 和 scipy.quad：（需要 202.76 秒）

import numpy as np
from scipy import integrate
from scipy.special import erf
from scipy.special import j0
import time

q = np.linspace(0.03, 1.0, 1000)

start = time.time()

def f(q, z, t):
    return t * 0.5 * (erf((t - z) / 3) …