123 lines
2.0 KiB
C++
123 lines
2.0 KiB
C++
#ifndef MIX_HPP
|
|
#define MIX_HPP
|
|
|
|
#include <cmath>
|
|
|
|
// Use like `Householder<double, 8>::inPlace(data)` - size must be ≥ 1
|
|
template<typename T, int size>
|
|
class Householder
|
|
{
|
|
static constexpr T multiplier{-2.0/size};
|
|
|
|
public:
|
|
static void inPlace(T *arr)
|
|
{
|
|
double sum = 0;
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
sum += arr[i];
|
|
}
|
|
|
|
sum *= multiplier;
|
|
|
|
for (int i = 0; i < size; ++i)
|
|
{
|
|
arr[i] += sum;
|
|
}
|
|
};
|
|
};
|
|
|
|
// Use like `Hadamard<double, 8>::inPlace(data)` - size must be a power of 2
|
|
template<typename T, int size>
|
|
class Hadamard
|
|
{
|
|
public:
|
|
static inline void recursiveUnscaled(T * data)
|
|
{
|
|
if (size <= 1)
|
|
{
|
|
return;
|
|
}
|
|
constexpr int hSize = size/2;
|
|
|
|
// Two (unscaled) Hadamards of half the size
|
|
Hadamard<T, hSize>::recursiveUnscaled(data);
|
|
Hadamard<T, hSize>::recursiveUnscaled(data + hSize);
|
|
|
|
// Combine the two halves using sum/difference
|
|
for (int i = 0; i < hSize; ++i)
|
|
{
|
|
double a = data[i];
|
|
double b = data[i + hSize];
|
|
data[i] = (a + b);
|
|
data[i + hSize] = (a - b);
|
|
}
|
|
}
|
|
|
|
static inline void inPlace(T * data)
|
|
{
|
|
recursiveUnscaled(data);
|
|
|
|
T scalingFactor = std::sqrt(1.0/size);
|
|
for (int c = 0; c < size; ++c)
|
|
{
|
|
data[c] *= scalingFactor;
|
|
}
|
|
}
|
|
};
|
|
|
|
template<typename T, uint size>
|
|
class Shuffle
|
|
{
|
|
public:
|
|
static inline void outOfPlace(T in[size], T out[size], const int shuffle_spec[size])
|
|
{
|
|
for (int c=0; c < size; c++)
|
|
{
|
|
T sign = 1;
|
|
int s = shuffle_spec[c];
|
|
if (s < 0)
|
|
{
|
|
sign = -1;
|
|
s *= -1;
|
|
}
|
|
if (s >= size)
|
|
{
|
|
s = 0;
|
|
}
|
|
|
|
out[s] = sign * in[c];
|
|
}
|
|
};
|
|
|
|
static inline void inPlace(T in_out[size], const int shuffle_spec[size])
|
|
{
|
|
T temp[size];
|
|
for (int c=0; c < size; c++)
|
|
{
|
|
temp[c] = in_out[c];
|
|
}
|
|
Shuffle<T, size>::outOfPlace(temp, in_out, shuffle_spec);
|
|
};
|
|
};
|
|
|
|
template<typename T, uint size>
|
|
class Mix
|
|
{
|
|
public:
|
|
static inline void split(T in, T out[size])
|
|
{
|
|
for (uint c=0; c < size; c++)
|
|
{
|
|
out[c] = in;
|
|
}
|
|
}
|
|
|
|
static inline T combine(T in_out[size])
|
|
{
|
|
Householder<T, size>::inPlace(in_out);
|
|
return in_out[0];
|
|
}
|
|
};
|
|
#endif
|