#include <iostream>
#include <vector>
#include <string>
#include <cmath>
#include <iomanip>
/** Range generation,
* from http://stackoverflow.com/questions/13313980/populate-an-array-using-constexpr-at-compile-time **/
template < unsigned ... Is > struct seq{ } ;
template < unsigned N, unsigned ... Is >
struct gen_seq : gen_seq< N- 1 , N- 1 , Is...> { } ;
template < unsigned ... Is >
struct gen_seq< 0 , Is...> : seq< Is...> { } ;
/** A table consisting of indexes and values,
* which will all be computed at compile-time **/
template < unsigned N>
struct Table
{
unsigned indexes[ N] ;
double values[ N] ;
static constexpr unsigned length = N;
} ;
template < typename LambdaType, unsigned ... Is >
constexpr Table< sizeof ...( Is) > TableGenerator( seq< Is...> , LambdaType evalFunc)
{
return { { Is... } , { evalFunc( Is) ... } } ;
}
template < unsigned N, typename LambdaType>
constexpr Table< N> TableGenerator( LambdaType evalFunc )
{
return TableGenerator( gen_seq< N> ( ) , evalFunc) ;
}
/** Function that computes a value for each index **/
constexpr double myFunc( unsigned idx )
{
return sin ( 0.2 * idx) + cos ( 0.5 * idx) ;
}
int main( )
{
constexpr unsigned length = 100 ;
// create compile-time table
constexpr Table< length> table = TableGenerator< length> ( myFunc ) ;
// print values in vertical form, pretty-looking ;)
const double lineMult = 12 ;
const double lineOffset = 30 ;
for ( auto v : table.values )
{
const unsigned numSpaces = ( unsigned ) ( lineOffset + v * lineMult + 0.5 ) ;
std:: cout << std:: setfill ( ' ' ) << std:: setw ( numSpaces ) << "o" << std:: endl ;
}
std:: cout << std:: endl ;
return 0 ;
}
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