limitMin.cpp

sample implementation and test - Tristan Matthews, 09/06/2009 10:19 pm

Download (2.7 kB)

 
1
#include <cassert>
2
#include <cmath>
3
#include <iostream>
4
#include <algorithm>
5




6
typedef unsigned char TTUInt8; 





7
typedef unsigned short TTUInt16; 





8




9
#ifdef __LP64__     // Mac 64-bit





10
    typedef unsigned int TTUInt32; 





11
#else   // Mac 32-bit, Win32 32-bit





12
    typedef unsigned long TTUInt32;





13
#endif





14




15
#if defined(_MSC_VER) || defined(__BORLANDC__)





16
    typedef unsigned __int64    TTUInt64;





17
#else





18
    #if defined(__LP64__)   // Mac 64-bit





19
        typedef unsigned long       TTUInt64;





20
    #else // Max 32-bit





21
        typedef unsigned long long  TTUInt64;





22
    #endif





23
#endif





24




25




26
template <class T>





27
T limitMin(T value, T low_bound)





28
{





29
    value -= low_bound;





30
#ifdef TT_PLATFORM_MAC





31
    value += fabs(value);





32
#else





33
    value = T(value + fabs((double)value));





34
#endif





35
    value = T(value * 0.5);





36
    value = T(value + low_bound);





37
    return value;





38




39
}





40




41




42
template <>





43
TTUInt8 limitMin(TTUInt8 value, TTUInt8 low_bound)





44
{





45
    value -= std::min(low_bound, value); // so 0 at lowest





46




47
#ifdef TT_PLATFORM_MAC





48
    value += fabs(value);





49
#else





50
    value = TTUInt8(value + fabs((double)value));





51
#endif





52
    value = TTUInt8(value * 0.5);





53
    value = TTUInt8(value + low_bound);





54
    return value;





55
}





56




57




58
template <>





59
TTUInt16 limitMin(TTUInt16 value, TTUInt16 low_bound)





60
{





61
    value -= std::min(low_bound, value); // so 0 at lowest





62




63
#ifdef TT_PLATFORM_MAC





64
    value += fabs(value);





65
#else





66
    value = TTUInt16(value + fabs((double)value));





67
#endif





68
    value = TTUInt16(value * 0.5);





69
    value = TTUInt16(value + low_bound);





70
    return value;





71
}





72




73




74
template <>





75
TTUInt32 limitMin(TTUInt32 value, TTUInt32 low_bound)





76
{





77
    value -= std::min(low_bound, value); // so 0 at lowest





78




79
#ifdef TT_PLATFORM_MAC





80
    value += fabs(value);





81
#else





82
    value = TTUInt32(value + fabs((double)value));





83
#endif





84
    value = TTUInt32(value * 0.5);





85
    value = TTUInt32(value + low_bound);





86
    return value;





87
}





88




89




90
template <>





91
TTUInt64 limitMin(TTUInt64 value, TTUInt64 low_bound)





92
{





93
    value -= std::min(low_bound, value); // so 0 at lowest





94




95
#ifdef TT_PLATFORM_MAC





96
    value += fabs(value);





97
#else





98
    value = TTUInt64(value + fabs((double)value));





99
#endif





100
    value = TTUInt64(value * 0.5);





101
    value = TTUInt64(value + low_bound);





102
    return value;





103
}





104




105




106
int main(int argc, char* argv[])





107
{





108
    if (argc != 3)





109
    {





110
        std::cout << "Usage: limitMin <value> <lowerBound>\n";





111
        return 1;





112
    }





113




114
    TTUInt16 u, l;





115
    std::cout << "Enter a value:\n";





116
    u = atoi(argv[1]);





117
    std::cout << "u is " << u << std::endl;





118
    std::cout << "Enter a lower bound:\n";





119
    l = atoi(argv[2]);





120
    std::cout << "l is " << l << std::endl;





121




122
    long long iterations = 100000000LL;





123




124
    // execute a lot of times





125
    while (iterations--)





126
        TTUInt16 v = limitMin<TTUInt16>(u, l);





127
    





128
    return 0;





129
}





130