struct pmf *z_generate(const struct pmf *t, unsigned int ts)
{
double sum;
unsigned int j, th;
struct pmf *z;
z = pmf_create(pmf_max(t) / ts * ts, 0);
th = ts;
sum = 0;
for (j = (unsigned int)pmf_min(t); j < (unsigned int)pmf_max(t); j++) {
if (j < ts) {
fprintf(stderr, "Error!!! Interarrival times MUST be greater than %d!!!\n",
ts);
return NULL;
}
if (j >= th) {
pmf_set(z, th - ts, sum);
th += ts;
sum = 0;
}
sum += pmf_get(t, j);
}
return z;
}
int pmf_read(struct pmf *d, FILE *f)
{
int cnt = 0;
while (!feof(f)) {
int res;
unsigned int i;
double p;
res = fscanf(f, "%u %lf\n", &i, &p);
if (res == 2) {
if (pmf_set(d, i, p) < 0) {
fprintf(stderr, "Failed to insert %u: PMF(%u)=%f\n", cnt, i, p);
return -1;
}
} else if (res != 0) {
perror("fscanf");
return -1;
}
cnt++;
}
return 1;
}
void pmf_normalise(struct pmf *s)
{
int i;
double sum;
sum = 0;
for (i = pmf_min(s); i <= pmf_max(s); i++) {
sum += pmf_get(s, i);
}
for (i = pmf_min(s); i <= pmf_max(s); i++) {
pmf_set(s, i, pmf_get(s, i) / sum);
}
}
void
virtual_pmf_isolate (virtual_pmf_t op)
{
if (op->index == -1)
return;
struct virtual_pmfvec_struct* parent = op->parent;
if (parent->count[op->index] == 1)
// already has reference count 1
return;
// detach
parent->count[op->index]--;
// find new buffer and copy the data
unsigned index = virtual_pmfvec_new_buf (parent);
pmf_set (parent->buf[index], parent->buf[op->index], parent->M);
op->index = index;
}
int main(int argc, char *argv[])
{
int opt;
struct pmf *c;
struct pmf *u;
struct pmf *c1;
uint64_t time_start, time_end;
int n, i, j;
Real prob = 0.0;
MAT *matrix;
opt = opts_parse(argc, argv);
if (strcmp(ofile, "") == 0) {
fprintf(stderr, "You must specify an output file.mat\n");
exit(0);
}
c = load(argv[opt], Nc);
c1 = pmf2cdf(c);
//print(c1,"c1");
time_start = get_time();
switch (model) {
case ETFAMODEL:{
if (z == 0)
u = load(argv[opt + 1], Nc);
else {
u = pmf_create(Nc, 0);
pmf_set(u, z, 1.0);
}
n = 100;
matrix = m_get(n, n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
prob = prob_efta(i, j, Q, c, u);
m_set_val(matrix, i, j, prob);
}
}
break;
}
case LASTMODEL:{
if (d == 0)
d = Q;
n = pmf_max(c) / d * 3;
matrix = m_get(n, n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
prob = prob_last(i, j, Q, z, d, c1);
m_set_val(matrix, i, j, prob);
}
}
break;
}
case RTSSMODEL:{
n = 10;
matrix = m_get(n, n);
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
prob = prob_rtss(i, j, Q, z, c);
m_set_val(matrix, i, j, prob);
}
}
break;
}
default:
fprintf(stderr, "Choose a model please\n");
exit(0);
}
time_end = get_time();
/*for (i=0; i<n; i++){
for (j=0; j<n; j++){
printf("%f ",m_get_val(matrix,i,j));
}
printf("\n");
}*/
//print(matrix);
FILE *fm = fopen(ofile, "w");
m_save(fm, matrix, "matrix");
fclose(fm);
return (0);
}
int
testcase_pmfvec_tpifft_dc (unsigned lgK, unsigned lgM, ulong n, int fwd,
ulong z, ulong t, const zn_mod_t mod)
{
int success = 1;
ulong M = 1UL << lgM;
ulong K = 1UL << lgK;
ulong i, j;
ptrdiff_t skip = M + 1;
// ===================================
// first check linearity, i.e. that ax + by gets mapped to the right thing
{
pmfvec_t X, Y, A, B, TX, TY;
pmfvec_init (X, lgK, skip, lgM, mod);
pmfvec_init (Y, lgK, skip, lgM, mod);
pmfvec_init (A, lgK, skip, lgM, mod);
pmfvec_init (B, lgK, skip, lgM, mod);
pmfvec_init (TX, lgK, skip, lgM, mod);
pmfvec_init (TY, lgK, skip, lgM, mod);
// generate random X, Y, A, B
for (i = 0; i < K; i++)
{
pmf_rand (X->data + i * skip, M, mod);
pmf_rand (Y->data + i * skip, M, mod);
}
pmf_rand (A->data, M, mod);
pmf_rand (B->data, M, mod);
for (i = 1; i < K; i++)
{
pmf_set (A->data + i * A->skip, A->data, M);
pmf_set (B->data + i * B->skip, B->data, M);
}
// transform X and Y (after throwing in random ignorable crap)
pmfvec_set (TX, X);
pmfvec_set (TY, Y);
for (i = n + fwd; i < K; i++)
{
pmf_rand (TX->data + i * skip, M, mod);
pmf_rand (TY->data + i * skip, M, mod);
}
pmfvec_tpifft_dc (TX, n, fwd, z, t);
pmfvec_tpifft_dc (TY, n, fwd, z, t);
// form linear combination of TX and TY
pmfvec_mul (TX, TX, A, z, 0);
pmfvec_mul (TY, TY, B, z, 0);
for (i = 0; i < z; i++)
pmf_add (TX->data + TX->skip * i, TY->data + TY->skip * i, M, mod);
// form linear combination of X and Y
pmfvec_mul (X, X, A, n + fwd, 0);
pmfvec_mul (Y, Y, B, n + fwd, 0);
for (i = 0; i < n + fwd; i++)
pmf_add (X->data + X->skip * i, Y->data + Y->skip * i, M, mod);
// transform linear combination of X and Y
pmfvec_tpifft_dc (X, n, fwd, z, t);
// compare results
for (i = 0; i < z; i++)
success = success && !pmf_cmp (X->data + X->skip * i,
TX->data + TX->skip * i, M, mod);
pmfvec_clear (X);
pmfvec_clear (Y);
pmfvec_clear (TX);
pmfvec_clear (TY);
pmfvec_clear (A);
pmfvec_clear (B);
}
// ===================================
// now check that the matrix of the transposed IFFT is really the transpose
// of the matrix of the ordinary IFFT
{
pmfvec_t* X = (pmfvec_t*) malloc (z * sizeof (pmfvec_t));
for (i = 0; i < z; i++)
pmfvec_init (X[i], lgK, skip, lgM, mod);
pmfvec_t* Y = (pmfvec_t*) malloc ((n + fwd) * sizeof (pmfvec_t));
for (i = 0; i < n + fwd; i++)
pmfvec_init (Y[i], lgK, skip, lgM, mod);
// compute images of basis vectors under FFT
for (i = 0; i < z; i++)
for (j = 0; j < z; j++)
{
pmf_zero (X[i]->data + j * skip, M);
X[i]->data[j * skip + 1] = (i == j);
}
for (i = 0; i < z; i++)
pmfvec_ifft (X[i], n, fwd, z, t);
// compute images of basis vectors under transposed FFT
for (i = 0; i < n + fwd; i++)
for (j = 0; j < n + fwd; j++)
{
pmf_zero (Y[i]->data + j * skip, M);
Y[i]->data[j * skip + 1] = (i == j);
}
for (i = 0; i < n + fwd; i++)
pmfvec_tpifft (Y[i], n, fwd, z, t);
// check that they are transposes of each other
for (i = 0; i < z; i++)
for (j = 0; j < n + fwd; j++)
success = success && !pmf_cmp (X[i]->data + j * skip,
Y[j]->data + i * skip, M, mod);
for (i = 0; i < z; i++)
pmfvec_clear (X[i]);
for (i = 0; i < n + fwd; i++)
pmfvec_clear (Y[i]);
free (Y);
free (X);
}
return success;
}
/*
If lgT == 0, this tests pmfvec_ifft_dc.
If lgT > 0, it tests pmfvec_ifft_huge.
*/
int
testcase_pmfvec_ifft_dc_or_huge (unsigned lgK, unsigned lgM, unsigned lgT,
ulong n, int fwd, ulong z, ulong t,
const zn_mod_t mod)
{
pmfvec_t A, B, C;
ulong M = 1UL << lgM;
ulong K = 1UL << lgK;
ulong x = zn_mod_reduce (K, mod);
ptrdiff_t skip = M + 1;
ulong i;
pmfvec_init (A, lgK, skip, lgM, mod);
pmfvec_init (B, lgK, skip, lgM, mod);
pmfvec_init (C, lgK, skip, lgM, mod);
// create random a_i's, with zero padding
for (i = z; i < K; i++)
pmf_zero (A->data + i * skip, M);
for (i = z; i < K; i++)
A->data[i * skip] = random_ulong (2 * M);
for (i = 0; i < z; i++)
pmf_rand (A->data + i * skip, M, mod);
// run FFT
pmfvec_set (B, A);
pmfvec_fft (B, K, K, t);
pmfvec_set (C, B);
// fill in missing data, plus junk where the implied zeroes should be
for (i = n; i < z; i++)
{
pmf_set (C->data + i * skip, A->data + i * skip, M);
pmf_scalar_mul (C->data + i * skip, M, x, mod);
}
for (i = z; i < K; i++)
pmf_rand (C->data + i * skip, M, mod);
// try IFFT
if (lgT > 0)
pmfvec_ifft_huge (C, lgT, n, fwd, z, t);
else
pmfvec_ifft_dc (C, n, fwd, z, t);
// compare results
int success = 1;
for (i = 0; i < n; i++)
pmf_scalar_mul (A->data + i * skip, M, x, mod);
for (i = 0; i < n; i++)
success = success && !pmf_cmp (C->data + i * skip, A->data + i * skip,
M, mod);
if (fwd)
success = success && !pmf_cmp (C->data + i * skip, B->data + i * skip,
M, mod);
pmfvec_clear (C);
pmfvec_clear (B);
pmfvec_clear (A);
return success;
}
int pmf_collect(struct pmf *s, int i)
{
return pmf_set(s, i, pmf_get(s, i) + 1);
}
