//we don't have to bother with making sure that gcd(R,M) == 1 since M is odd.
uberzahl modexp_mm(mm_t & mm, uberzahl base, uberzahl exp, uberzahl M){
if(!mm.initialized){
mm.R = next_power(M);
mm.Rbits = mm.R.bitLength();
mm.Mprime = (mm.R-M.inverse(mm.R));
uberzahl z("1");
uberzahl t("2");
mm.Rsq = modexp(mm.R,t,M);
//mm.z_init = mm.R % M;
mm.z_init = montgomery_reduction(mm.Rsq, M, mm.Mprime, mm.Rbits, mm.R);
mm.initialized = true;
}
//convert into Montgomery space
uberzahl z = mm.z_init;
//According to Piazza post we don't even need to calculate the residues with mod
if(base * mm.Rsq < mm.R*M)
base = montgomery_reduction(base * mm.Rsq, M, mm.Mprime, mm.Rbits, mm.R);
else
base = base * mm.R % M;
mediumType i = exp.bitLength() - 1;
while(i >= 0) {
z = montgomery_reduction(z * z, M, mm.Mprime, mm.Rbits, mm.R);
if(exp.bit(i) == 1){
z = montgomery_reduction(z * base , M, mm.Mprime, mm.Rbits, mm.R);
}
if(i == 0)
break;
i -= 1;
}
return montgomery_reduction(z, M, mm.Mprime, mm.Rbits, mm.R);
}
/* Expand or create the hashtable */
int ht_expand(struct hashtable *t, size_t size)
{
struct hashtable n; /* the new hashtable */
unsigned int realsize = next_power(size), i;
/* the size is invalid if it is smaller than the number of
* elements already inside the hashtable */
if (t->used >= size)
return HT_INVALID;
ht_init(&n);
n.size = realsize;
n.sizemask = realsize-1;
n.table = malloc(realsize*sizeof(struct ht_ele*));
if (n.table == NULL)
return HT_NOMEM;
/* Copy methods */
n.hashf = t->hashf;
n.key_destructor = t->key_destructor;
n.val_destructor = t->val_destructor;
n.key_compare= t->key_compare;
/* Initialize all the pointers to NULL */
memset(n.table, 0, realsize*sizeof(struct ht_ele*));
/* Copy all the elements from the old to the new table:
* note that if the old hash table is empty t->size is zero,
* so ht_expand() acts like an ht_create() */
n.used = t->used;
for (i = 0; i < t->size && t->used > 0; i++) {
if (t->table[i] != NULL && t->table[i] != ht_free_element) {
u_int32_t h;
/* Get the new element index: note that we
* know that there aren't freed elements in 'n' */
h = n.hashf(t->table[i]->key) & n.sizemask;
if (n.table[h]) {
n.collisions++;
while(1) {
h = (h+1) & n.sizemask;
if (!n.table[h])
break;
n.collisions++;
}
}
/* Move the element */
n.table[h] = t->table[i];
t->used--;
}
}
assert(t->used == 0);
free(t->table);
/* Remap the new hashtable in the old */
*t = n;
return HT_OK;
}
struct buffer_node* buffernode_new(unsigned long len)
{
struct buffer_node * ret;
len = next_power(len);
ret = (struct buffer_node *)malloc(sizeof(*ret) + len);
ret->next = NULL;
ret->size = len;
ret->in = 0;
ret->out = 0;
return ret;
}
/* Initialize an allocated hash table. */
int hash_init(hash_t *ht, unsigned int slots) {
assert(ht);
ht->slots = next_power(slots);
ht->count = 0;
ht->data = (hash_entry_t **)calloc(ht->slots, sizeof(hash_entry_t *));
if (!ht->data) {
return -1;
}
return 0;
}
static int buffer_extendby(buffer_t *buf, size_t extby)
{
char *data;
size_t newlen = _unlikely_(!buf->buflen && extby < 64)
? 64 : buf->len + extby;
if (newlen > buf->buflen) {
newlen = next_power(newlen);
data = realloc(buf->data, newlen);
if (!data)
return -errno;
buf->buflen = newlen;
buf->data = data;
}
return 0;
}
/**
* NAME: pad_matrix
* INPUT: MATRIX* mOrig, MARIX* mNew
* USAGE: Converts a matrix to the smallest 2^n by 2^n square matrix.
* Pads missing values with 0. Stores the result in mNew.
* Original Input is unmodified.
*
* NOTES: Assumes mOrig and mNew are already initalized.
*/
void pad_matrix(MATRIX* mOrig, MATRIX* mNew)
{
// Calculate the new dimensions.
int origDims;
if(mOrig->numRows > mOrig->numCols)
origDims = mOrig->numRows;
else
origDims = mOrig->numCols;
int newDims = next_power(origDims);
// Allocate memory for the new matrix and add zeros.
zero_matrix(newDims, newDims, mNew);
for(int i = 0; i < newDims; i++)
{
for (int j=0; j< newDims; j++)
// Grab entries if they are in the original matrix.
// Otherwise, pad with 0.
if(i < mOrig->numRows && j < mOrig->numCols)
mNew->matrix[i][j] = mOrig->matrix[i][j];
}
}
