int main(int argc, char * argv[])
{
if(argc != 2)
return 1; // invalid number of parameters
int n = std::atoi(argv[1]);
//Get Triangular Number:
int triangularNr = triangular(n);
//Check for error value (-1):
if(triangularNr == -1){
std::cout << "domain = [0;" << maximum << "],codomain = [0;" ;
pretty_print(triangular(maximum));
std::cout << "]\n";
}
//Print answer:
else{
std::cout << n << "-te Dreieckszahl: ";
pretty_print(triangularNr);
std::cout << "\n";
}
return 0;
}
void find_triplet(int in) {
//int out[3];
int try1, try2, try3, t1remainder, t2remainder, t3remainder;
for (try1 = 1; try1 < find_next_triangular(in); try1++) {
t1remainder = in - triangular(try1);
//printf("t1remainder: %i", t1remainder);
if (t1remainder == 0) {
printf("%i = %i\n", in, triangular(try1));
return;
} else {
for (try2 = 1; try2 < find_next_triangular(t1remainder); try2++) {
t2remainder = t1remainder - triangular(try2);
if (t2remainder == 0) {
printf("%i = %i + %i\n", in, triangular(try1), triangular(try2));
return;
} else {
for (try3 = 1; try3 < find_next_triangular(t2remainder); try3++) {
t3remainder = t2remainder - triangular(try3);
if (t3remainder == 0) {
printf("%i = %i + %i + %i \n", in, triangular(try1), triangular(try2), triangular(try3));
return;
}
}
}
}
}
}
}
int main(int argc, char * argv[])
{
if(argc != 2)
return 1; // invalid number of parameters
int n = std::atoi(argv[1]);
const int CoDomainMin = 1; //lowest possible value
const int CoDomainMax = pow(2, sizeof(int) * 8 - 1) -1; //Max value for int
const int DomainMin = 1; //Defined in formula
const int DomainMax = GetDomainMax(CoDomainMax); //Calculate this value because sizeof(int) could change
if ( (n > DomainMax) || (n < DomainMin) ) {
std::cout << "domain = [";
pretty_print(DomainMin); std::cout << ";"; pretty_print(DomainMax);
std::cout << "], codomain = [";
pretty_print(CoDomainMin); std::cout << ";"; pretty_print(CoDomainMax);
std::cout << "]" << std::endl;
return 2;
}
pretty_print(triangular(n)); std::cout << std::endl;
//std::cout << "Hello World";
return 0;
}
int find_next_triangular(int i) {
int next_triangular_index = 0;
while(triangular(next_triangular_index) <= i) {
next_triangular_index++;
}
return next_triangular_index;
}
/* Evaluates the specified membership function in the given 'x' value */
static double
eval_MF (MF_t mf, double x)
{
switch (mf.k) {
case (triang):
return triangular (mf.p[0], mf.p[1], mf.p[2], x);
break;
case (trap):
return trapezoidal (mf.p[0], mf.p[1], mf.p[2], mf.p[3], x);
break;
case (gauss):
return gaussian (mf.p[0], mf.p[1], x);
break;
case (bell):
return belly (mf.p[0], mf.p[1], mf.p[2], x);
break;
default:
fprintf (stderr, "anfis.c: eval_MF: ERROR: unknown MF\n");
return 0.0;
break;
}
}
int find_next_triangular(int in) {
int cur = 1;
int cur_triangular = 0;
while (1) {
cur_triangular = triangular(cur);
// printf("Cur: %i, Cur_tri: %i \n", cur, cur_triangular);
if (cur_triangular > in) {
return cur;
}
cur ++;
}
}
unsigned int divisoresTriangular(unsigned int x){ //Cant. de divisores de cada numero triangular
long long n;
long long i;
unsigned int cant = 0; //Cantidad de divisores del numero triangular
n = triangular(x);
i = n;
while (i > 0){
if (n%i == 0){
cant++;
}
i--;
}
return cant;
}
void test_eigen2_triangular()
{
CALL_SUBTEST_8( selfadjoint() );
for(int i = 0; i < g_repeat ; i++) {
CALL_SUBTEST_1( triangular(Matrix<float, 1, 1>()) );
CALL_SUBTEST_2( triangular(Matrix<float, 2, 2>()) );
CALL_SUBTEST_3( triangular(Matrix3d()) );
CALL_SUBTEST_4( triangular(MatrixXcf(4, 4)) );
CALL_SUBTEST_5( triangular(Matrix<std::complex<float>,8, 8>()) );
CALL_SUBTEST_6( triangular(MatrixXd(17,17)) );
CALL_SUBTEST_7( triangular(Matrix<float,Dynamic,Dynamic,RowMajor>(5, 5)) );
}
}
double *xtract_init_window(const int N, const int type)
{
double *window;
window = malloc(N * sizeof(double));
switch (type)
{
case XTRACT_GAUSS:
gauss(window, N, 0.4);
break;
case XTRACT_HAMMING:
hamming(window, N);
break;
case XTRACT_HANN:
hann(window, N);
break;
case XTRACT_BARTLETT:
bartlett(window, N);
break;
case XTRACT_TRIANGULAR:
triangular(window, N);
break;
case XTRACT_BARTLETT_HANN:
bartlett_hann(window, N);
break;
case XTRACT_BLACKMAN:
blackman(window, N);
break;
case XTRACT_KAISER:
kaiser(window, N, 3 * PI);
break;
case XTRACT_BLACKMAN_HARRIS:
blackman_harris(window, N);
break;
default:
hann(window, N);
break;
}
return window;
}
void find_triplet(int in, int out[]) {
int max_index = find_next_triangular(in);
for (int i = 0; i < max_index; i++) {
for (int j = 0; j < max_index; j++) {
for (int k = 0; k < max_index; k++) {
if (triangular(i) + triangular(j) + triangular(k) == in) {
out[0] = triangular(i);
out[1] = triangular(j);
out[2] = triangular(k);
return;
}
}
}
}
}
int main(int argc, char *argv[]){
unsigned long ti=1, pi=1, hi=1;
unsigned long tn, pn, hn;
unsigned long found = 0;
tn=triangular(ti);
pn=pentagonal(pi);
hn=hexagonal(hi);
do{
while(pn < hn) pi++;
if(pi > num_pn) { pi = num_pn; find_all_upto(pn[num_pn]*3); continue;}
if(hn[hi] < pn[pi]) { hi++; printf("."); continue;}
ti = pi;
while(tn[ti] < pn[pi]) ti++;
if(ti > num_tn) { ti = num_tn; find_all_upto(tn[num_tn]*3); continue;}
if(pn[pi] < tn[ti]) { pi++; printf(","); continue;}
if(pn[pi] == hn[hi] && hn[hi] == tn[ti]) {
found++;
hi++; printf("\n%lu %lu %lu %lu\n", tn[ti], ti, pi, hi);
}
} while(found<2)
return 0;
}
// create spgram object
// _nfft : FFT size
// _wtype : window type, e.g. LIQUID_WINDOW_HAMMING
// _window_len : window length
// _delay : delay between transforms, _delay > 0
SPGRAM() SPGRAM(_create)(unsigned int _nfft,
int _wtype,
unsigned int _window_len,
unsigned int _delay)
{
// validate input
if (_nfft < 2) {
fprintf(stderr,"error: spgram%s_create(), fft size must be at least 2\n", EXTENSION);
exit(1);
} else if (_window_len > _nfft) {
fprintf(stderr,"error: spgram%s_create(), window size cannot exceed fft size\n", EXTENSION);
exit(1);
} else if (_window_len == 0) {
fprintf(stderr,"error: spgram%s_create(), window size must be greater than zero\n", EXTENSION);
exit(1);
} else if (_wtype == LIQUID_WINDOW_KBD && _window_len % 2) {
fprintf(stderr,"error: spgram%s_create(), KBD window length must be even\n", EXTENSION);
exit(1);
} else if (_delay == 0) {
fprintf(stderr,"error: spgram%s_create(), delay must be greater than 0\n", EXTENSION);
exit(1);
}
// allocate memory for main object
SPGRAM() q = (SPGRAM()) malloc(sizeof(struct SPGRAM(_s)));
// set input parameters
q->nfft = _nfft;
q->wtype = _wtype;
q->window_len = _window_len;
q->delay = _delay;
q->frequency = 0;
q->sample_rate= -1;
// set object for full accumulation
SPGRAM(_set_alpha)(q, -1.0f);
// create FFT arrays, object
q->buf_time = (TC*) malloc((q->nfft)*sizeof(TC));
q->buf_freq = (TC*) malloc((q->nfft)*sizeof(TC));
q->psd = (T *) malloc((q->nfft)*sizeof(T ));
q->fft = FFT_CREATE_PLAN(q->nfft, q->buf_time, q->buf_freq, FFT_DIR_FORWARD, FFT_METHOD);
// create buffer
q->buffer = WINDOW(_create)(q->window_len);
// create window
q->w = (T*) malloc((q->window_len)*sizeof(T));
unsigned int i;
unsigned int n = q->window_len;
float beta = 10.0f;
float zeta = 3.0f;
for (i=0; i<n; i++) {
switch (q->wtype) {
case LIQUID_WINDOW_HAMMING: q->w[i] = hamming(i,n); break;
case LIQUID_WINDOW_HANN: q->w[i] = hann(i,n); break;
case LIQUID_WINDOW_BLACKMANHARRIS: q->w[i] = blackmanharris(i,n); break;
case LIQUID_WINDOW_BLACKMANHARRIS7: q->w[i] = blackmanharris7(i,n); break;
case LIQUID_WINDOW_KAISER: q->w[i] = kaiser(i,n,beta,0); break;
case LIQUID_WINDOW_FLATTOP: q->w[i] = flattop(i,n); break;
case LIQUID_WINDOW_TRIANGULAR: q->w[i] = triangular(i,n,n); break;
case LIQUID_WINDOW_RCOSTAPER: q->w[i] = liquid_rcostaper_windowf(i,n/3,n); break;
case LIQUID_WINDOW_KBD: q->w[i] = liquid_kbd(i,n,zeta); break;
default:
fprintf(stderr,"error: spgram%s_create(), invalid window\n", EXTENSION);
exit(1);
}
}
// scale by window magnitude, FFT size
float g = 0.0f;
for (i=0; i<q->window_len; i++)
g += q->w[i] * q->w[i];
g = M_SQRT2 / ( sqrtf(g / q->window_len) * sqrtf((float)(q->nfft)) );
// scale window and copy
for (i=0; i<q->window_len; i++)
q->w[i] = g * q->w[i];
// reset the spgram object
q->num_samples_total = 0;
q->num_transforms_total = 0;
SPGRAM(_reset)(q);
// return new object
return q;
}
