def _naivefrechetconv(self, other, op='*'):
if op == '+':
return self._frechetconv(other, '+')
if op == '-':
return self._frechetconv(-other, '+')
if op == '/':
return self._naivefrechetconv(other.reciprocal(), '*')
# x = makepbox(x)
# y = makepbox(y)
n = len(self.hi)
c = (utils.get_op(op)([[i] for i in self.hi], other.hi)).flatten()
c.sort()
Zd = c[np.array(range(n * n - n, n * n))]
c = (utils.get_op(op)([[i] for i in self.lo], other.lo)).flatten()
c.sort()
Zu = c[np.array(range(n))]
# mean
m = interval.Interval(self.mean_lo, self.mean_hi) * interval.Interval(
other.mean_lo, other.mean_hi)
a = np.sqrt(
interval.Interval(self.var_lo, self.var_hi) *
interval.Interval(other.var_lo, other.var_hi))
ml = m - a
mh = m + a
VK = vkmean.VKmeanproduct(self, other)
m = utils.imp(interval.Interval(ml, mh), VK)
# variance
vl = 0
vh = np.inf
pbox_parms = {
"hi": Zd,
"lo": Zu,
"mean_lo": utils.left(m),
"mean_hi": utils.right(m),
"var_lo": vl,
"var_hi": vh
}
return Pbox(**pbox_parms)
def dwVariance(pbox):
if np.any(np.isinf(pbox.lo)) or np.any(np.isinf(pbox.hi)):
return interval.Interval(0, np.inf)
if np.all(pbox.hi[0] == pbox.hi) and np.all(pbox.lo[0] == pbox.lo):
return interval.Interval(0, (pbox.hi[0] - pbox.lo[0])**(2 / 4))
vr = sideVariance(pbox.lo, np.mean(pbox.lo))
w = np.copy(pbox.lo)
n = len(pbox.lo)
for i in reversed(range(n)):
w[i] = pbox.hi[i]
v = sideVariance(w, np.mean(w))
if np.isnan(vr) or np.isnan(v):
vr = np.inf
elif vr < v:
vr = v
if pbox.lo[n - 1] <= pbox.hi[0]:
vl = 0.0
else:
w = np.copy(pbox.hi)
vl = sideVariance(w, np.mean(w))
for i in reversed(range(n)):
w[i] = pbox.lo[i]
here = w[i]
if 1 < i:
for j in reversed(range(i - 1)):
if w[i] < w[j]:
w[j] = here
v = sideVariance(w, np.mean(w))
if np.isnan(vl) or np.isnan(v):
vl = 0
elif v < vl:
vl = v
return interval.Interval(vl, vr)
def imp_interval(*args):
mmm = args[0]
for each in args:
mmm = interval.Interval(lo=np.max([left(mmm), left(each)]),
hi=np.min([right(mmm), right(each)]))
# should check whether they now cross
if mmm.hi < mmm.lo:
warnings.warn('Imposition is empty')
mmm = None
return mmm
def transformedVariancePos2ndDeriv(B, t, posderiv, transformedMean):
result1 = transformedVarianceByIntervalComp(B, t, posderiv,
transformedMean)
if result1 is None: #np.isnan(result1):
return None
else:
result2 = transformedVarianceByRowesPos2ndDeriv(
B, t, posderiv, transformedMean)
result_lower = np.max([result1.lo, result2.lo])
result_upper = np.min([result1.hi, result2.hi])
return interval.Interval(result_lower, result_upper)
def transformedVariance(B, t, posderiv, pos2ndderiv, transformedMean):
if pos2ndderiv is None: #np.isnan(pos2ndderiv):
return transformedVarianceByIntervalComp(B, t, posderiv,
transformedMean)
elif pos2ndderiv:
return transformedVariancePos2ndDeriv(B, t, posderiv, transformedMean)
else:
newT = lambda x: (-1) * t(x)
newTransformedMean = interval.Interval((-1) * (transformedMean.hi),
(-1) * (transformedMean.lo))
return transformedVariancePos2ndDeriv(B, newT, not posderiv,
newTransformedMean)
def _checkmoments(self):
a = interval.Interval(self.mean_lo, self.mean_hi) #mean(x)
b = utils.dwMean(self)
self.mean_lo = np.max([utils.left(a), utils.left(b)])
self.mean_hi = np.min([utils.right(a), utils.right(b)])
if self.mean_hi < self.mean_lo:
# use the observed mean
self.mean_lo = utils.left(b)
self.mean_hi = utils.right(b)
a = interval.Interval(self.var_lo, self.var_hi) #var(x)
b = utils.dwVariance(self)
self.var_lo = np.max([utils.left(a), utils.left(b)])
self.var_hi = np.min([utils.right(a), utils.right(b)])
if self.var_hi < self.var_lo:
# use the observed variance
self.var_lo = utils.left(b)
self.var_hi = utils.right(b)
def VKmeanproduct(a, b):
# Interval ea,eb,ec,pa,pb;
# double la,ra,lb,rb,k1,k2,k3,k4,ec1,ec2;
ec = interval.Interval(-np.inf, np.inf)
ea = interval.Interval(a.mean_lo, a.mean_hi)
eb = interval.Interval(b.mean_lo, b.mean_hi)
la = utils.left(a)
ra = utils.right(a)
lb = utils.left(b)
rb = utils.right(b)
k1 = ra * rb
k2 = ra * lb
k3 = la * rb
k4 = la * lb
pa = interval.Interval((utils.left(ea) - la) / (ra - la),
(utils.right(ea) - la) / (ra - la))
pb = interval.Interval((utils.left(eb) - lb) / (rb - lb),
(utils.right(eb) - lb) / (rb - lb))
ec = utils.env_int(VKmeanlower(pa, pb, k1, k2, k3, k4),
VKmeanupper(pa, pb, k1, k2, k3, k4))
return ec
def getIntervalDistance(lower1, upper1, lower2, upper2):
dis_lower = 0
dis_upper = 0
if upper1 <= lower2:
dis_lower = lower2 - upper1
dis_upper = upper2 - lower1
elif lower1 >= upper2:
dis_lower = lower1 - upper2
dis_upper = upper1 - lower2
else:
dis_lower = 0
dis_upper = np.max([np.abs(lower1 - upper2), np.abs(lower2 - upper1)])
return interval.Interval(dis_lower, dis_upper)
def transformedMean(B, t, posderiv, pos2ndderiv):
if pos2ndderiv is None: # np.isnan(pos2ndderiv):
return transformedMeanNull2ndDeriv(B, t, posderiv)
elif pos2ndderiv:
return transformedMeanPos2ndDeriv(B, t, posderiv)
else:
newT = lambda x: (-1) * t(x)
tempResult = transformedMeanPos2ndDeriv(B, newT, not posderiv)
if tempResult is None: # np.isnan(tempResult):
transformedMean_lower = (-1) * (tempResult.hi)
transformedMean_upper = (-1) * (tempResult.lo)
return interval.Interval(transformedMean_lower,
transformedMean_upper)
else:
return None
def transformedVarianceByIntervalComp(B, t, posderiv, transformedMean):
transformedMean_lower = transformedMean.lo
transformedMean_upper = transformedMean.hi
transformedSum = 0
for j in range(B.n):
transformedSum += t(B.lo[j])
currentTransformedMean = transformedSum / (B.n)
if posderiv:
if currentTransformedMean > transformedMean_upper:
return None
else:
if currentTransformedMean < transformedMean_lower:
return None
transformedSum = 0
for j in range(B.n):
transformedSum += t(B.hi[j])
currentTransformedMean = transformedSum / (B.n)
if posderiv:
if currentTransformedMean < transformedMean_lower:
return None
else:
if currentTransformedMean > transformedMean_upper:
return None
transformedVariance_lower = transVarLowerByIntervalCompPos2ndDeriv(
B, t, posderiv, transformedMean)
transformedVariance_upper = transVarUpperByIntervalCompPos2ndDeriv(
B, t, posderiv, transformedMean)
if transformedVariance_lower is None or transformedVariance_upper is None: #np.isnan(transformedVariance_lower) or np.isnan(transformedVariance_upper):
return None
else:
return interval.Interval(transformedVariance_lower,
transformedVariance_upper)
def transformedVarianceByRowesPos2ndDeriv(B, t, posderiv, transformedMean):
m = B.lo[0]
M = B.hi[B.n - 1]
mu_lower = B.mean_lo
mu_upper = B.mean_hi
v_lower = B.var_lo
v_upper = B.var_hi
transformedMean_lower = transformedMean.lo
transformedMean_upper = transformedMean.hi
eta_lower = optimize.brentq(lambda x: t(x) - transformedMean_lower,
a=m,
b=M,
xtol=0.0001)
eta_upper = optimize.brentq(lambda x: t(x) - transformedMean_upper,
a=m,
b=M,
xtol=0.0001)
if posderiv:
transformedVariance_lower = (transformedMean_lower - t(m))**2 / (
eta_lower - m)**2 * (v_lower + getIntervalDistance(
eta_lower, eta_lower, mu_lower, mu_upper).lo**2)
transformedVariance_upper = (transformedMean_upper - t(M))**2 / (
eta_upper - M)**2 * (v_upper + getIntervalDistance(
eta_upper, eta_upper, mu_lower, mu_upper).hi**2)
else:
transformedVariance_lower = (transformedMean_upper - t(M))**2 / (
eta_upper - M)**2 * (v_upper + getIntervalDistance(
eta_upper, eta_upper, mu_lower, mu_upper).lo**2)
transformedVariance_upper = (transformedMean_lower - t(m))**2 / (
eta_lower - m)**2 * (v_lower + getIntervalDistance(
eta_lower, eta_lower, mu_lower, mu_upper).hi**2)
return interval.Interval(transformedVariance_lower,
transformedVariance_upper)
def transformedMeanNull2ndDeriv(B, t, posderiv):
transformedMean_lower = None
transformedMean_upper = None
transformedSum = 0
for i in range(B.n):
transformedSum += t(B.lo[i])
if posderiv:
transformedMean_lower = transformedSum / (B.n)
else:
transformedMean_upper = transformedSum / (B.n)
transformedSum = 0
for i in range(B.n):
transformedSum += t(B.hi[i])
if posderiv:
transformedMean_upper = transformedSum / (B.n)
else:
transformedMean_lower = transformedSum / (B.n)
return interval.Interval(transformedMean_lower, transformedMean_upper)
def dwMean(p_box):
return interval.Interval(np.mean(p_box.hi), np.mean(p_box.lo))
def env_int(*args):
lo = min([min(i) if is_iterable(i) else i for i in args])
hi = max([max(i) if is_iterable(i) else i for i in args])
return interval.Interval(lo, hi)
def transformedMeanPos2ndDeriv(B, t, posderiv):
mu_lower = B.mean_lo
mu_upper = B.mean_hi
ssum = 0
transformedSum = 0
for i in range(B.n):
ssum += B.lo[i]
transformedSum += t(B.lo[i])
computedMu_lower = ssum / (B.n)
if posderiv:
transformedMean_lower = transformedSum / (B.n)
else:
transformedMean_upper = transformedSum / (B.n)
ssum = 0
transformedSum = 0
for i in range(B.n):
ssum += B.hi[i]
transformedSum += t(B.hi[i])
computedMu_upper = ssum / (B.n)
if posderiv:
transformedMean_upper = transformedSum / (B.n)
else:
transformedMean_lower = transformedSum / (B.n)
if computedMu_lower > mu_upper or computedMu_upper < mu_lower:
return None
elif computedMu_lower >= mu_lower and computedMu_upper <= mu_upper:
return interval.Interval(transformedMean_lower, transformedMean_upper)
else:
if posderiv:
if computedMu_lower < mu_lower:
transformedMean_lower = None
if computedMu_upper > mu_upper:
transformedMean_upper = None
else:
if computedMu_lower < mu_lower:
transformedMean_upper = None
if computedMu_upper > mu_upper:
transformedMean_lower = None
if transformedMean_lower is None: # np.isnan(transformedMean_lower):
if posderiv:
mu = mu_lower
else:
mu = mu_upper
endingPoints = getBoundEndingPoints(B)
ssum = 0
transformedSum = 0
for i in range(B.n):
ssum += B.lo[i]
transformedSum += t(B.lo[i])
num_middle = 0
computedMu = ssum / (B.n)
if computedMu >= mu_lower and computedMu <= mu_upper:
transformedMean_lower = transformedSum / (B.n)
for i in range(2 * (B.n)):
if endingPoints[1, i] < 0:
ssum -= endingPoints[0, i]
transformedSum -= t(endingPoints[0, i])
num_middle += 1
else:
ssum = +endingPoints[0, i]
transformedSum += t(endingPoints[0, i])
num_middle -= 1
if num_middle == 0:
computedMu = ssum / (B.n)
if computedMu >= mu_lower and computedMu <= mu_upper:
currentTransformedMean = transformedSum / (B.nn)
if transformedMean_lower is None: # np.isnan(transformedMean_lower):
transformedMean_lower = currentTransformedMean
else:
transformedMean_lower = min(transformedMean_lower,
currentTransformedMean)
else:
value_middle = (mu * (B.n) - ssum) / num_middle
if value_middle >= endingPoints[
0, i] and value_middle <= endingPoints[0, i + 1]:
currentTransformedMean = (
transformedSum + t(value_middle) * num_middle) / (B.n)
if transformedMean_lower is None: # np.isnan(transformedMean_lower):
transformedMean_lower = currentTransformedMean
else:
transformedMean_lower = min(transformedMean_lower,
currentTransformedMean)
if transformedMean_upper is None: # np.isnan(transformedMean_upper):
if posderiv:
mu = mu_upper
else:
mu = mu_lower
ssum = mu * (B.n)
sum_lower = 0
transformedSum_lower = 0
for i in range(B.n):
sum_lower += B.hi[i]
transformedSum_lower = transformedSum_lower + t(B.hi[i])
for i in range(B.n):
sum_upper = sum_lower
transformedSum_upper = transformedSum_lower
sum_lower += (B.lo[i] - B.hi[i])
transformedSum_lower += (t(B.lo[i]) - t(B.hi[i]))
if ssum >= sum_lower and ssum <= sum_upper:
a = (sum_upper - ssum) / (B.hi[i] - B.lo[i])
currentTransformedMean = (transformedSum_upper - a *
(t(B.hi[i]) - t(B.lo[i]))) / (B.n)
if transformedMean_upper is None: #np.isnan(transformedMean_upper):
transformedMean_upper = currentTransformedMean
else:
transformedMean_upper = max(transformedMean_upper,
currentTransformedMean)
return interval.Interval(transformedMean_lower, transformedMean_upper)
