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)