标签: piecewise

我试图将分段线性拟合拟合为数据集,如图1所示

这个数字是通过设置线条获得的.我试图使用代码应用分段线性拟合:

from scipy import optimize
import matplotlib.pyplot as plt
import numpy as np


x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ,11, 12, 13, 14, 15])
y = np.array([5, 7, 9, 11, 13, 15, 28.92, 42.81, 56.7, 70.59, 84.47, 98.36, 112.25, 126.14, 140.03])


def linear_fit(x, a, b):
    return a * x + b
fit_a, fit_b = optimize.curve_fit(linear_fit, x[0:5], y[0:5])[0]
y_fit = fit_a * x[0:7] + fit_b
fit_a, fit_b = optimize.curve_fit(linear_fit, x[6:14], y[6:14])[0]
y_fit = np.append(y_fit, …

该标准模板std::pair和std::array有特殊情况std::tuple,它按理说,他们应该有一个非常类似的功能集.

然而,三者中唯一的,std::pair允许分段构造.也就是说,如果该类型T1并T2可以从一组参数来构建a1, a2, ...和b1, b2, ...,然后讲道德,我们可以做一对

"pair<T1, T2> p(a1, a2, ..., b1, b2, ...)"

直.实际上,这是拼写为这样的:

std::pair<T1, T2> p(std::piecewise_construct,
                    std::forward_as_tuple(a1, a2, ...),
                    std::forward_as_tuple(b1, b2, ...));

问题:为什么阵列和元组不存在相同的分段构造性？有一个深刻的原因,还是一个普通的遗漏？例如,拥有以下内容会很高兴:

std::tuple<T1, T2, T3> t(std::piecewise_construct,
                         std::forward_as_tuple(a1, a2, ...),
                         std::forward_as_tuple(b1, b2, ...),
                         std::forward_as_tuple(c1, c2, ...));

有没有理由不能这样做？[ 编辑:或者我是否完全误解了分段建设的目的？]

(我确实有一种情况,我希望初始化一个带有默认元素值的元组向量,我宁愿直接从参数构造,而不是再次拼写出每个元组元素类型.)

在N3059中,我找到了对(和元组)的分段构造的描述(它在新标准中).

但是我不知道什么时候应该使用它.我发现了关于emplace和不可复制实体的讨论,但是当我尝试它时,我无法创建一个我需要 piecewiese_construct或可以看到性能优势的案例.

例.我以为我需要一个不可复制的类,但是movebale(转发需要):

struct NoCopy {
  NoCopy(int, int) {};
  NoCopy(const NoCopy&) = delete; // no copy
  NoCopy& operator=(const NoCopy&) = delete; // no assign
  NoCopy(NoCopy&&) {}; // please move
  NoCopy& operator=(NoCopy&&) {}; // please move-assign
};

然后,我想到标准对构造会失败:

pair<NoCopy,NoCopy> x{ NoCopy{1,2}, NoCopy{2,3} }; // fine!

但事实并非如此.实际上,这是我所期望的,因为"移动东西"而不是在stdlib中的任何地方复制它应该是.

因此,我认为我没有理由这样做,或者说:

pair<NoCopy,NoCopy> y(
    piecewise_construct,
    forward_as_tuple(1,2),
    forward_as_tuple(2,3)
); // also fine

• 那么,什么是用例？
• 我如何以及何时使用piecewise_construct？

我有54​​分.它们代表产品的供应和需求.我想表明这个提议有一个突破点.

首先,我对x轴(商品)进行排序并删除出现两次的值.我有47个值,但我删除了第一个和最后一个(将它们视为断点没有意义).休息长度为45:

Break<-(sort(unique(offer))[2:46])

然后,对于这些潜在断点中的每一个,我估计一个模型并且我在"d"中保留残差标准误差(模型汇总对象中的第六个元素).

d<-numeric(45)
for (i in 1:45) {
model<-lm(demand~(offer<Break[i])*offer + (offer>=Break[i])*offer)
d[i]<-summary(model)[[6]] }

绘制d,我注意到我的较小残差标准误差为34,对应于"Break [34]":22.4.所以我用最后的断点来写我的模型:

model<-lm(demand~(offer<22.4)*offer + (offer>=22.4)*offer)

最后,我对我的新模特感到满意.它比简单的线性好得多.我想画它:

plot(demand~offer)
i <- order(offer)
lines(offer[i], predict(model,list(offer))[i])

但我有一条警告信息:

Warning message:
In predict.lm(model, list(offer)) :
  prediction from a rank-deficient fit may be misleading

更重要的是,我的情节上的线条真的很奇怪.

这是我的数据:

demand <- c(1155, 362, 357, 111, 703, 494, 410, 63, 616, 468, 973, 235,
            180, 69, 305, 106, 155, 422, 44, 1008, 225, 321, 1001, 531, 143,
            251, 216, 57, 146, 226, 169, 32, 75, 102, …

我试图在Matlab中生成一个分段符号函数.它必须是符号的原因是我希望能够在之后集成/区分函数和/或插入实际值.我有以下功能:

x^3/6   ->   0 < x <= 1
(1/6)*(-3*x^3+12*x^2-12x+4)   ->   1 < x <= 2
(1/6)*(3*x^3-24*x^2+60x-44)   ->   2 < x <= 3
(1/6)*(4-x)^3   ->   3 < x <= 4
0   ->   otherwise

例如,我想把这个函数放在一个变量中(比如说f),然后调用

int(diff(f, 1)^2, x, 0, 4) % numbers could be different

得到(标量)结果2/3.

我尝试了各种各样的事情,涉及分段()函数和符号比较,但没有任何效果......你能帮忙吗？:-)

我有一个应用程序,我需要定义一个分段函数,IE,f(x)= g(x)为[x在某个范围内],f(x)= h(x)为[x在某些其他范围] ,......等

在朱莉娅有一个很好的方法吗？我宁愿不使用if-else,因为我似乎必须检查x的大值的每个范围.我想的方法是构造一个函数数组和一个边界/范围数组,然后当调用f(x)时,对范围进行二元搜索以找到适当的索引并使用相应的函数(IE, h(x),g(x)等

似乎这种数学友好的语言可能具有一些功能,但文档没有以这种方式分段提及.希望其他人给出了一些想法,谢谢!

我正在学习模糊系统课程,并在计算机上记笔记.这意味着我必须不时在我的计算机上绘制图形.由于这些图形定义得很好,我觉得用它们绘图numpy是一个好主意(我用LaTeX做笔记,我在python shell上很快,所以我想我可以侥幸逃脱).

模糊隶属函数的图形是高度分段的,例如:

为了绘制这个,我尝试了以下代码numpy.piecewise(这给了我一个神秘的错误):

In [295]: a = np.arange(0,5,1)

In [296]: condlist = [[b<=a<b+0.25, b+0.25<=a<b+0.75, b+0.75<=a<b+1] for b in range(3)]
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-296-a951e2682357> in <module>()
----> 1 condlist = [[b<=a<b+0.25, b+0.25<=a<b+0.75, b+0.75<=a<b+1] for b in range(3)]

ValueError: The truth value of an array with more than one element is ambiguous. Use a.any() or a.all()

In [297]: funclist = list(itertools.chain([lambda x:-4*x+1, lambda x: 0, lambda x:4*x+1]*3))

In [298]: np.piecewise(a, …

假设我们有五个顶点:

X = [0 1;
     2 1;
     4 1;
     1 0;
     3 0];

三角测量:

T = [1 4 2;
     4 5 2;
     5 3 2];

和顶点上定义的函数值:

Fx = [1;
      2;
      3;
      4;
     -5];

然后我们可以通过使用重心坐标轻松计算三角形内任何点的函数值.对于P = [1 .5]位于第一个三角形中的点,重心坐标为B = [.25 .5 .25],因此函数的计算结果为Fxi = 1/4 + 4/2 + 2/4 = 2.75.

但是,我很难看出如何推断这个表面.我们可以找到最接近的三角形并从中推断出来.问题是这会导致不连续的功能.考虑例如点P = [2 2].根据三角形1,其值为-0.5,而根据三角形3,其值为9.5.

是否有"标准"或普遍接受的方法从分段线性函数中推断出来？任何指向现有材料的指针也非常赞赏.

我已经使用了一些代码中的代码如何在Python中应用分段线性拟合？,用单个断点执行分段线性逼近.

代码如下:

from scipy import optimize
import matplotlib.pyplot as plt
import numpy as np
%matplotlib inline

x = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10 ,11, 12, 13, 14, 15], dtype=float)
y = np.array([5, 7, 9, 11, 13, 15, 28.92, 42.81, 56.7, 70.59, 84.47, 98.36, 112.25, 126.14, 140.03])

def piecewise_linear(x, x0, y0, k1, k2):
    return np.piecewise(x, 
                       [x < x0], 
                       [lambda x:k1*x + y0-k1*x0, lambda x:k2*x + y0-k2*x0])

p , e = optimize.curve_fit(piecewise_linear, x, y)
xd …

我试图将数据分为两部分.

这是一些示例数据:

x<-c(0.00101959664756622, 0.001929220749155, 0.00165657261751726, 
0.00182514724375389, 0.00161532360585458, 0.00126991061099209, 
0.00149545009309177, 0.000816386510029308, 0.00164402569283353, 
0.00128029006251656, 0.00206892841921455, 0.00132378793976235, 
0.000953143467154676, 0.00272964503695939, 0.00169743839571702, 
0.00286411493120396, 0.0016464862337286, 0.00155672067449593, 
0.000878271561566836, 0.00195872573138819, 0.00255412836538339, 
0.00126212428137799, 0.00106206607962734, 0.00169140916371657, 
0.000858015581562961, 0.00191955159274793, 0.00243104345247067, 
0.000871042201994687, 0.00229814264111745, 0.00226756341241083)

y<-c(1.31893118849162, 0.105150790530179, 0.412732029152914, 0.25589805483046, 
0.467147868109498, 0.983984462069833, 0.640007862668818, 1.51429617241365, 
0.439777145282391, 0.925550163462951, -0.0555942758921906, 0.870117027565708, 
1.38032147826294, -0.96757052387814, 0.346370836378525, -1.08032147826294, 
0.426215616848312, 0.55151485221263, 1.41306889485598, 0.0803478641720901, 
-0.86654892295057, 1.00422341998656, 1.26214517662281, 0.359512373951839, 
1.4835398594013, 0.154967053938309, -0.680501679226447, 1.44740598234453, 
-0.512732029152914, -0.359512373951839)

我希望能够定义最合适的两部分线(显示的手绘示例)

然后我定义了一个分段函数,它应该找到一个两部分线性函数.该定义基于两条线的梯度和它们彼此的截距,它们应该完全定义线.

# A=gradient of first line segment
# B=gradient of second line segment
# Cx=inflection point x …