Question

我可能有一个简单的问题,使我已经平静下来了。是否有一种简单的办法,可以把两个被划为(非分析)数据集的交汇回平方?

详细情况,我有这样的情况:

x=[1.4,2.1,3,5.9,8,9,23]
y=[2.3,3.1,1,3.9,8,9,11]
x1=[1,2,3,4,6,8,9]
y1=[4,12,7,1,6.3,8.5,12]
plot(x1,y1, k- ,x,y, b- )

这方面的数据完全是任意的。我现在想知道,我是否在职能上有一个简单的建构,而我却把两个地块混为一谈。

我希望我表明自己,而且我也假想出一个完全明显的错误......

Answer 1

We could use scipy.interpolate.PiecewisePolynomial to create functions which are defined by your piecewise-linear data.

p1=interpolate.PiecewisePolynomial(x1,y1[:,np.newaxis])
p2=interpolate.PiecewisePolynomial(x2,y2[:,np.newaxis])

那么,我们就可以区分这两项职能,

def pdiff(x):
    return p1(x)-p2(x)

http://docs.scipy.org/doc/scipy/vis/generated/scipy.optimize.fsolve.html#scipy-optimize-fsolve”rel=“noreferer”_optimize.fsolve,以找到pdiff的根源:

import scipy.interpolate as interpolate
import scipy.optimize as optimize
import numpy as np

x1=np.array([1.4,2.1,3,5.9,8,9,23])
y1=np.array([2.3,3.1,1,3.9,8,9,11])
x2=np.array([1,2,3,4,6,8,9])
y2=np.array([4,12,7,1,6.3,8.5,12])    

p1=interpolate.PiecewisePolynomial(x1,y1[:,np.newaxis])
p2=interpolate.PiecewisePolynomial(x2,y2[:,np.newaxis])

def pdiff(x):
    return p1(x)-p2(x)

xs=np.r_[x1,x2]
xs.sort()
x_min=xs.min()
x_max=xs.max()
x_mid=xs[:-1]+np.diff(xs)/2
roots=set()
for val in x_mid:
    root,infodict,ier,mesg = optimize.fsolve(pdiff,val,full_output=True)
    # ier==1 indicates a root has been found
    if ier==1 and x_min<root<x_max:
        roots.add(root[0])
roots=list(roots)        
print(np.column_stack((roots,p1(roots),p2(roots))))

产量

[[ 3.85714286  1.85714286  1.85714286]
 [ 4.60606061  2.60606061  2.60606061]]

第1栏是X-数值,第2栏是第一个PecewisePolynomial在x上评价的,第3栏是第二栏目PecewisePolynomial的 y-数值。

Answer 2

<>Paramet> 解决办法

如果序列{x1,y1}和{x2,y2}界定了任意(x,y)曲线,而不是(x)曲线,我们需要一种分辨率的方法,以找到交叉点。既然这样说并非完全清楚,因为“@unutbu”的解决办法在SciPy使用一个错误的推论者,我认为重新讨论这个问题可能是有益的。

import numpy as np
from numpy.linalg import norm
from scipy.optimize import fsolve
from scipy.interpolate import interp1d
import matplotlib.pyplot as plt

x1_array = np.array([1,2,3,4,6,8,9])
y1_array = np.array([4,12,7,1,6.3,8.5,12])
x2_array = np.array([1.4,2.1,3,5.9,8,9,23])
y2_array = np.array([2.3,3.1,1,3.9,8,9,11])

s1_array = np.linspace(0,1,num=len(x1_array))
s2_array = np.linspace(0,1,num=len(x2_array))

# Arguments given to interp1d:
#  - extrapolate: to make sure we don t get a fatal value error when fsolve searches
#                 beyond the bounds of [0,1]
#  - copy: use refs to the arrays
#  - assume_sorted: because s_array ( x ) increases monotonically across [0,1]
kwargs_ = dict(fill_value= extrapolate , copy=False, assume_sorted=True)
x1_interp = interp1d(s1_array,x1_array, **kwargs_)
y1_interp = interp1d(s1_array,y1_array, **kwargs_)
x2_interp = interp1d(s2_array,x2_array, **kwargs_)
y2_interp = interp1d(s2_array,y2_array, **kwargs_)
xydiff_lambda = lambda s12: (np.abs(x1_interp(s12[0])-x2_interp(s12[1])),
                             np.abs(y1_interp(s12[0])-y2_interp(s12[1])))

s12_intercept, _, ier, mesg 
    = fsolve(xydiff_lambda, [0.5, 0.3], full_output=True) 

xy1_intercept = x1_interp(s12_intercept[0]),y1_interp(s12_intercept[0])
xy2_intercept = x2_interp(s12_intercept[1]),y2_interp(s12_intercept[1])

plt.plot(x1_interp(s1_array),y1_interp(s1_array), b. , ls= - , label= x1 data )
plt.plot(x2_interp(s2_array),y2_interp(s2_array), r. , ls= - , label= x2 data )
if s12_intercept[0]>0 and s12_intercept[0]<1:
    plt.plot(*xy1_intercept, bo , ms=12, label= x1 intercept )
    plt.plot(*xy2_intercept, ro , ms=8, label= x2 intercept )
plt.legend()

print( intercept @ s1={}, s2={}
 .format(s12_intercept[0],s12_intercept[1]), 
       intercept @ xy1={}
 .format(np.array(xy1_intercept)), 
       intercept @ xy2={}
 .format(np.array(xy2_intercept)), 
       fsolve apparent success? {}: "{}"
 .format(ier==1,mesg,), 
       is intercept really good? {}
 .format(s12_intercept[0]>=0 and s12_intercept[0]<=1 
      and s12_intercept[1]>=0 and s12_intercept[1]<=1 
      and np.isclose(0,norm(xydiff_lambda(s12_intercept)))) )

返回原住者,选择最初的gues [0.5,0.3]:

intercept @ s1=0.4761904761904762, s2=0.3825944170771757
intercept @ xy1=[3.85714286 1.85714286]
intercept @ xy2=[3.85714286 1.85714286]
fsolve apparent success? True: "The solution converged."
is intercept really good? True

这种方法只发现一个交叉点:我们需要在几个初步的电离层(如“unutbu s代码”那样)中进行消化,检查其真实性,并用<代码>np.close消除重复。请注意,fsolve 可不实地表明在收益价值ier<>code/code>中成功地发现了交叉点,这就是为什么在此进行额外核对的原因。


Here s the plot for this solution:

Answer 3

可使用。

import numpy as np
import matplotlib.pyplot as plt
import pandas as pd

x1 = np.array([1.4,2.1,3,5.9,8,9,23], dtype=float)
y1 = np.array([2.3,3.1,1,3.9,8,9,11], dtype=float)
x2 = np.array([1,2,3,4,6,8,9], dtype=float)
y2 = np.array([4,12,7,1,6.3,8.5,12], dtype=float)

# plt.plot(x1,y1, ko- ,x2,y2, bo- )
# plt.show()

##https://stackoverflow.com/questions/55225385/intersection-point-between-2d-arrays
def intersection(X1, X2):
    x = np.union1d(X1[0], X2[0])
    y1 = np.interp(x, X1[0], X1[1])
    y2 = np.interp(x, X2[0], X2[1])
    dy = y1 - y2

    ind = (dy[:-1] * dy[1:] < 0).nonzero()[0]
    x1, x2 = x[ind], x[ind+1]
    dy1, dy2 = dy[ind], dy[ind+1]
    y11, y12 = y1[ind], y1[ind+1]
    y21, y22 = y2[ind], y2[ind+1]

    x_int = x1 - (x2 - x1) * dy1 / (dy2 - dy1)
    y_int = y11 + (y12 - y11) * (x_int - x1) / (x2 - x1)
    return x_int, y_int

res = intersection([x1, y1], [x2, y2])
print(res)
if len(res)!=0:
    t=np.array(res); print(t)
    d= pd.DataFrame(t.T, columns= [ x ,  y ]); print(d)

plt.plot(x1,y1, ko- ,x2,y2, bo- , d.x, d.y,  ro )
plt.show()

友情链接