Limits

// Example program
#include <iostream>
#include <string>

template <typename A>
A myMax(A a,A b)      //this is an overload, not specialization
{
   if (a>b)
      return a;
   else
      return b;
}

template <typename A, typename ... Args>
A myMax(A a, A b, Args ... args)
{
   return myMax(myMax(a,b),args...);
}

template <typename A>
A myMin(A a,A b)      //this is an overload, not specialization
{
   if (a<b)
      return a;
   else
      return b;
}

template <typename A, typename ... Args>
A myMin(A a, A b, Args ... args)
{
   return myMin(myMin(a,b),args...);
}

struct Limits {
    Limits() : lower(0), upper(0) {}
    long long int lower;
    long long int upper;
};

std::ostream& operator<<(std::ostream& os, const Limits& limits) {
    os << "[" << limits.lower << ", " << limits.upper << "]";
    return os;
}

Limits getLimitsPlus(Limits l1, Limits l2) {
    Limits result;
    result.lower = l1.lower + l2.lower;
    result.upper = l1.upper + l2.upper;
    return result;
}

Limits getLimitsMinus(Limits lhs, Limits rhs) {
    Limits result;
    result.lower = myMin(lhs.lower-rhs.lower,
                         lhs.lower-rhs.upper,
                         lhs.upper-rhs.lower,
                         lhs.upper-rhs.upper
                         );
    result.upper = myMax(lhs.lower-rhs.lower,
                         lhs.lower-rhs.upper,
                         lhs.upper-rhs.lower,
                         lhs.upper-rhs.upper
                         );
    return result;
}

Limits getLimitsMultiply(Limits l1, Limits l2) {
    Limits result;
    result.upper = myMax(l1.lower*l2.lower,
                         l1.lower*l2.upper,
                         l1.upper*l2.lower,
                         l1.upper*l2.upper
                         );
    result.lower = myMin(l1.lower*l2.lower,
                         l1.lower*l2.upper,
                         l1.upper*l2.lower,
                         l1.upper*l2.upper
                         );
    return result;
}

Limits getLimitsDivide(Limits lhs, Limits rhs) {
    Limits result;
    result.upper = myMax(lhs.lower/rhs.lower,
                          lhs.lower/rhs.upper,
                          lhs.upper/rhs.lower,
                          lhs.lower/rhs.upper
                          );
    result.lower = myMin(lhs.lower/rhs.lower,
                          lhs.lower/rhs.upper,
                          lhs.upper/rhs.lower,
                          lhs.lower/rhs.upper
                          );
    return result;
}

int main()
{
    Limits lhs, rhs;
    lhs.lower = -127;
    lhs.upper = 127;
    rhs.lower = 0;
    rhs.upper = 255;
    std::cout << "RHS: " << rhs << std::endl;
    std::cout << "LHS: " << lhs << std::endl;
    Limits resultPlus, resultMinus, resultMultiply, resultDivide;
    resultPlus = getLimitsPlus(lhs, rhs);
    resultMinus = getLimitsMinus(lhs, rhs);
    resultMultiply = getLimitsMultiply(lhs, rhs);
    resultDivide = getLimitsDivide(lhs, rhs);
    std::cout << lhs << " + " << rhs << " " << resultPlus << std::endl;
    std::cout << lhs << " - " << rhs << " " << resultMinus << std::endl;
    std::cout << lhs << " * " << rhs << " " << resultMultiply << std::endl;
    std::cout << lhs << " / " << rhs << " " << resultDivide << std::endl;
}