 }
 public func / <T:ArithmeticBound>(lhs:ClosedInterval<T>, rhs:T)->ClosedInterval<T> {
     return interval(lo:lhs.lo/rhs, hi:lhs.hi/rhs)
+}
+public func / <T:ArithmeticBound>(lhs:T, rhs:ClosedInterval<T>)->ClosedInterval<T> {
+    return interval(lhs, margin:0) / rhs
 }
 infix operator +- { associativity none precedence 145 }
 infix operator ± { associativity none precedence 145 }

///
/// - parameter f: monotonic function that takes T and returns T
/// - returns: a function that takes Interval<T> and returns Interval<T>
public func monotonicFunc<T:ArithmeticBound>(f:T->T)->(ClosedInterval<T>->ClosedInterval<T>) {
    return { x in
        let l = f(x.lo)
        let h = f(x.hi)
        return interval(lo:min(l, h), hi:max(l, h))
    }
}
// monotonic
public func sqrt<T:ArithmeticBound>(x:ClosedInterval<T>)->ClosedInterval<T> {
    return interval(lo:T.sqrt(x.lo), hi:T.sqrt(x.hi))
}

    let hh = lhs.hi * rhs.hi
    return interval(lo:min(ll, lh, hl, hh), hi:max(ll, lh, hl, hh))
}
public func * <T:ArithmeticBound>(lhs:ClosedInterval<T>, rhs:T)->ClosedInterval<T> {
    let ll = lhs.lo * rhs
    let lh = lhs.lo * rhs
    let hl = lhs.hi * rhs
    let hh = lhs.hi * rhs
    return interval(lo:min(ll, lh, hl, hh), hi:max(ll, lh, hl, hh))
}
public func * <T:ArithmeticBound>(lhs:T, rhs:ClosedInterval<T>)->ClosedInterval<T> {
    return rhs * lhs
}
public func / <T:ArithmeticBound>(lhs:ClosedInterval<T>, rhs:ClosedInterval<T>)->ClosedInterval<T> {
    guard rhs.lo.isSignMinus == rhs.hi.isSignMinus else {
        return interval(lo:-(T.infinity), hi:+(T.infinity))
