# Math Functions

## Lerp

``````float bit::Math::lerp(float val1, float val2, float ratio)
{
return val1 + ratio * (val2 - val1);
}``````

## Clamp

``````float bit::Math::clamp(float value, float min, float max)
{
return (value > max ? max : (value < min ? min : value));
}``````

## Round

``````float bit::Math::round(float value)
{
return std::floor(value + 0.5);
}``````

## Floor Power of 2

``````float bit::Math::floorPowerOf2(float value)
{
if(value > 1) // 32 bit twiddling
{
int v = (int)value;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
return v - (v >> 1);
}
else
{
// domains: 0, .125, .25, .5, 1
if(value == 0)
return 0;
if(value > 0 && value < .125)
return 0;
if(value >= .125 && value < .25)
return .125;
if(value >= .25 && value < .5)
return .25;
if(value >= .5 && value < 1)
return .5;
else
return 1;
}
}``````

## Ceiling Power of 2

``````float bit::Math::ceilPowerOf2(float value)
{
if(value > 1) // 32 bit twiddling
{
int v = (int)value;
v--;
v |= v >> 1;
v |= v >> 2;
v |= v >> 4;
v |= v >> 8;
v |= v >> 16;
v++;
return v;
}
else
{
// domains: 0, .125, .25, .5, 1
if(value == 0)
return 0;
if(value > 0 && value <= .125)
return .125;
if(value > .125 && value <= .25)
return .25;
if(value > .25 && value <= .5)
return .5;
else
return 1;
}
}``````

## Round to Power of 2

``````float bit::Math::roundPowerOf2(float value)
{
float ceil = ceilPowerOf2(value);
float floor = floorPowerOf2(value);
if(std::abs(ceil - value) < std::abs(value - floor))
return ceil;
else
return floor;
}``````

## Bitwise Has Any

``````bool bit::Math::bitwiseHasAny(unsigned int value, unsigned int filter)
{
return (value & filter) > 0;
}``````

## Bitwise Has All

``````bool bit::Math::bitwiseHasAll(unsigned int value, unsigned int filter)
{
return (value & filter) == filter;
}``````

## Hash from String

``````unsigned int bit::Math::toHash(std::string const&st)
{
// s[0]*31^(n - 1) + s[1]*31^(n - 2) + ... + s[n - 1]
// where s[i] is the ith character of the string, n is the length of the string, and ^ indicates exponentiation
unsigned int tally = 0;
for(unsigned int i = 0; i < st.size(); i++)
{
unsigned int pos = i + 1;
char s = st[i];
double d = (double)s;
tally += d * std::pow((double)31, (double)(pos - 1));
}

return tally;
}``````