int PrimeFactor(long x)
{
/* Start with the first prime */
int prime = 2;
if (IsPrime(x))
{
printf("Found prime factor %ld\n", x);
return x;
}
/* Find the next prime that divides cleanly */
while ( x % prime != 0 )
prime = NextPrime(prime);
printf("Factoring %ld, found prime %d\n", x, prime);
x /= prime; /* Divide the value by the prime factor */
/* Shall we continue? */
if (!IsPrime(x))
PrimeFactor(x);
else
printf("Found prime factor %ld\n", x);
return x;
}
HashTable InitializeTable(int TableSize)
{
HashTable H;
int i;
if(TableSize < MinTableSize)
{
Error("Table Size too Small");
return NULL;
}
H = malloc(sizeof(struct HashTable));
if(H == NULL)
FatalError("Out of space!");
H->TableSize = NextPrime(TableSize);
H->TheLists = malloc(sizeof(List) * H->TableSize);
if(H->TheLists == NULL)
FatalError("Out of space!");
for(i = 0; i < H->TableSize; i++)
{
H->TheLists[i] = malloc(sizeof(struct ListNode));
if(H->TheLists[i] == NULL)
FatalError("Out of space!");
else
H->TheLists[i]->Next = NULL;
}
}
HashTable InitializeTable(int TableSize) {
HashTable H;
int i;
if (TableSize < MinTableSize) {
Error("Table size too small");
return NULL;
}
H = malloc(sizeof(struct HashTbl));
if (H == NULL) {
FatalError("Out of space!!!");
}
H->TableSize = NextPrime(TableSize);
H->TheCells = malloc(sizeof(Cell) * H->TableSize);
if (H->TheCells == NULL) {
FatalError("Out of space!!!");
}
for (i = 0; i < H->TableSize; i++) {
H->TheCells[i].Info = Empty;
}
return H;
}
/*InitializeTable分离链接散列表的初始化*/
HashTable InitializeTable(int TableSize){
HashTable H;
int i;
if(TableSize < MinTableSize){
printf("Table is too small\n");
return NULL;
}
H = malloc(sizeof(HashTbl));
if(H != NULL){
H->TableSize = NextPrime(TableSize);
H->TheList = malloc(sizeof(List) * H->TableSize);
if(H->TheList == NULL){
printf("Out of spzce!!!\n");
}
for(i = 0;i < H->TableSize;i++){
H->TheList[i] = malloc(sizeof(LinkNode));
if(H->TheList[i] == NULL){
printf("Out of space!!!\n");
}else{
H->TheList[i]->nextPtr = NULL;
}
}
}else{
printf("Out of space!!!\n");
}
return H;
}
// p is prime and p = 1 mod 4
vector<ZZ> CommonFunctions::decomposePrime(const ZZ &p, int stat) {
ZZ b;
if((p % 8) == to_ZZ(5)) {
b = to_ZZ(2);
}
else {
b = to_ZZ(3);
while(PowerMod(b, (p-1)/2, p) == 1) {
// next prime(b) returns the smallest prime larger than b
b = NextPrime(b, stat);
}
}
b = PowerMod(b, (p-1)/4, p);
// b is now an imaginary unit, i.e. b^2 = -1 mod p
ZZ a;
a = p;
while(power(b, 2) > p) {
ZZ temp = a;
a = b;
b = temp % b;
}
// cout << "a : " << a << " b : " << b << endl;
vector<ZZ> twoSquares;
twoSquares.push_back(b);
twoSquares.push_back(a % b);
return twoSquares;
}
/* START: fig5_15.txt */
HashTable
InitializeTable( int TableSize )
{
HashTable H;
int i;
/* 1*/ if( TableSize < MinTableSize )
{
/* 2*/ printf( "Table size too small" );
/* 3*/ return NULL;
}
/* Allocate table */
/* 4*/ H = malloc( sizeof( struct HashTbl ) );
/* 5*/ if( H == NULL )
/* 6*/ printf( "Out of space!!!" );
/* 7*/ H->TableSize = NextPrime( TableSize );
/* Allocate array of Cells */
/* 8*/ H->TheCells = malloc( sizeof( Cell ) * H->TableSize );
/* 9*/ if( H->TheCells == NULL )
/*10*/ printf( "Out of space!!!" );
/*11*/ for( i = 0; i < H->TableSize; i++ )
/*12*/ H->TheCells[ i ].Info = Empty;
/*13*/ return H;
}
//初始化
HashTable InitHashTable(int TableSize)
{
HashTable H;
if (TableSize < MinTableSize)
{
printf("Error! Table size too small!\n");
return NULL;
}
//分配空间给散列表
H = HashTable(malloc(sizeof(struct HashTbl)));
if (H == NULL)
printf("Error! Out of space!\n");
H->TableSize = NextPrime(TableSize);
//分配空间给每一个链表
H->TheLists = (List*)(malloc(sizeof(List)*H->TableSize));
if (H->TheLists == NULL)
printf("Error! Out of space!\n");
for (int i = 0; i < H->TableSize; ++i)
{
H->TheLists[i] = List(malloc(sizeof(struct ListNode)));
if (H->TheLists[i] == NULL)
printf("Error! Out of space!\n");
else
H->TheLists[i]->next = NULL;
}
return H;
}
HashTable
InitializeTable(int TableSize)
{
HashTable H;
int i;
H = malloc(sizeof(struct HashTbl));
if (H == NULL) {
FatalError("No memory space!");
}
H->TableSize = NextPrime(TableSize);
H->TheCells = malloc(sizeof(Cell) * H->TableSize);
if (H->TheCells == NULL) {
FatalError("No memory space!");
}
for (i = 0; i < H->TableSize; i++) {
H->TheCells[i].Info = Empty;
H->TheCells[i].Element = 0;
}
return H;
}
HashTable InitializTable( int TableSize ){
HashTable H;
int i;
H = malloc( sizeof( struct HashTbl ) );
if( H == NULL ){
printf( "Out of space" );
exit( -1 );
}
H->TableSize = NextPrime( TableSize );
printf( "%d\n",H->TableSize );
H->TheLists = malloc( sizeof( struct HashTbl ) * TableSize );
if( H->TheLists == NULL ){
printf( "Out of space" );
exit( -1 );
}
for( i = 0;i < H->TableSize;i++ ){
H->TheLists[i] = malloc( sizeof( struct ListNode ) );
if( H->TheLists[i] == NULL ){
printf( "Out of space" );
exit( -1 );
}else{
H->TheLists[i] = NULL;
}
}
return H;
}
Int Primes::GenPrime(Int size, boost::mt19937 *randNumGen)
{
Int beg = 1;
boost::uniform_int<> degen_dist(1 << (size-1), 1 << size);
boost::variate_generator<boost::mt19937&, boost::uniform_int<> > sampler(*randNumGen, degen_dist);
beg = sampler();
beg = NextPrime(beg);
return beg;
}
HashTable* InitHashTable(int n) {
HashTable* h;
int i;
h = (HashTable *)malloc(sizeof(HashTable));
h->size = NextPrime(n); /* Better be prime */
h->list = (ListNode **)malloc(sizeof(ListNode *) * h->size);
for( i = 0; i < h->size; i++ ) { /* Allocate list headers */
h->list[i] = (ListNode *)malloc(sizeof(ListNode));
h->list[i]->next = NULL;
}
return h;
}
NTL_CLIENT
// Программа для генерации задачи дискретного логарифмирования заданной размерности
// Образующая и модуль - D1 гладкие
int main() {
ZZ a,b,p,r; //основание, степень, модуль, порядок циклической группы, образованной основанием
ZZ x; //Показатель
long len; //Длина модуля
//Спросим длину модуля
//Фактически, модуль будет иметь длину len+1 двоичных разрядов
cin >> len;
//Простое число Жермен - p - простое и 2*p+1 - тоже простое
//Генерируем число заданной размерности (в двоичных разрядах)
p=GenGermainPrime_ZZ(len);
//Порядок циклической группы будет p-1. Мы будем искать образующую :)
//Всё так, как учил нас Великий Шнайер в Красной Книге
r=2*p;
//Модуль
p=2*p+1;
a=2;
//Найдём образующую
while ((PowerMod(a,2,p)==1) || (PowerMod(a,(p-1)/2,p)==1)) {
a=NextPrime(a+1);
}
//Получим степень b
b=2;
if (b==a)
b=NextPrime(b+1);
//Выдадим задачу на стандартный вывод
cout << a << endl << b << endl << p << endl << r << endl;
//Вот программе и конец, а кто - кодил - молодец!
return 0;
}
state_probability_queue::state_probability_queue(unsigned long mas)
: max_active_states((unsigned long) (mas * gPercentActiveStates))
{
stateArray = new state_and_probability_pair[max_active_states];
hashtable_size = NextPrime((unsigned long) mas);
table = new state_and_probability_pair[hashtable_size];
Full = new dynBitVec(hashtable_size);
#ifndef SPLITFILE
if ((paging_file_top = tmpfile()) == NULL) {
Error.Notrace("Internal: Error creating top paging file.");
}
if ((paging_file_bottom = tmpfile()) == NULL) {
Error.Notrace("Internal: Error creating bottom paging file.");
}
#else
paging_file_top = new splitFile(SPLITFILE_LEN, false);
paging_file_bottom = new splitFile(SPLITFILE_LEN, false);
if (!
(paging_file_top->open
(make_unique_filename(SFQ_PAGING_FILE_TOP), "w+b"))) {
Error.Notrace("Internal: Error creating top paging file for s_f_q.");
}
if (!
(paging_file_bottom->open
(make_unique_filename(SFQ_PAGING_FILE_BOTTOM), "w+b"))) {
Error.Notrace("Internal: Error creating bottom paging file.");
}
#endif
num_elts_head = num_elts_tail = 0;
head_begin = 0;
tail_begin = max_active_states / 2;
head_size = max_active_states / 2;
tail_size = max_active_states - head_size;
global_front = global_rear = front = rear = 0;
}
void DynamicSieve<T,TSmall>::SetStorage( bool keepAll )
{
if( keepAll && !keepAll_ )
{
// Ensure that we have all of the primes below lowerBound_ stored
if( lowerBound_ > oddPrimes.back()+2 )
{
T lowerBoundSave = lowerBound_;
lowerBound_ = oddPrimes.back()+2;
MoveSegmentOffset( lowerBound_ );
keepAll_ = true;
while( lowerBound_ < lowerBoundSave )
NextPrime();
}
}
keepAll_ = keepAll;
}
PHASHTABLE InitializeTable(unsigned int tableSize)
{
PHASHTABLE pHashTable = NULL;
PTWOWAY pNode = NULL;
unsigned int i;
// Allocate space for the hashtable
pHashTable = ExAllocatePoolWithTag(NonPagedPool, sizeof(HASHTABLE), DRIVERTAG1);
if (pHashTable == NULL)
{
DbgPrint("ExAllocatePoolWithTag returned NULL!\n");
return NULL;
}
pHashTable->tableSize = NextPrime(tableSize);
// Allocate array of pointers to linkedlists
pHashTable->pListHeads = ExAllocatePoolWithTag(NonPagedPool, sizeof(PLIST_ENTRY) * pHashTable->tableSize, DRIVERTAG1);
if (pHashTable->pListHeads == NULL)
{
DbgPrint("ExAllocatePoolWithTag returned NULL!\n");
return NULL;
}
// Allocate space for the lookaside list for the TWOWAY-structures.
pLookasideList_TWOWAY = ExAllocatePoolWithTag(NonPagedPool, sizeof(NPAGED_LOOKASIDE_LIST), DRIVERTAG1);
if (pLookasideList_TWOWAY == NULL)
{
DbgPrint("ExAllocatePoolWithTag returned NULL!\n");
return NULL;
}
// Initialize the lookaside list.
ExInitializeNPagedLookasideList(
pLookasideList_TWOWAY,
NULL,
NULL,
0,
sizeof(TWOWAY),
DRIVERTAG1,
0);
// Allocate empty nodes for the each linked list.
for (i = 0; i < pHashTable->tableSize; i++)
{
pNode = ExAllocateFromNPagedLookasideList(pLookasideList_TWOWAY);
if (pNode == NULL)
{
DbgPrint("ExAllocateFromNPagedLookasideList returned NULL!\n");
return NULL;
}
else
{
pNode->key = 0x00000000;
RtlZeroMemory(&pNode->data, sizeof(ELEMENT));
InitializeListHead(&pNode->linkfield);
}
pHashTable->pListHeads[i] = &pNode->linkfield;
}
return pHashTable;
}
void main(){
unsigned Mersenne[500], S[500], T[500], quot[500], res[500];
int a[500];
int p, j, k, t, d, r;
p = 5;
while(p <525){
Initialize(Mersenne);
Mersenne[0] = 1;
LongLeftShift(Mersenne, p);
Initialize(a);
a[0] = 1;
Sub(Mersenne, a); // Mersenne = 2 の p 乗 - 1
printf("p = %d \n", p);
// Display(Mersenne);
Initialize(S);
S[0] = 4;
for(j = 1; j<p-1; j++){
Copy(S, a);
LongMul(S, a); // S -> S^2
Initialize(a);
a[0] = 2;
Sub(S, a); // S -> S^2 - 2
LongDiv(S, Mersenne, quot, res);
if(DivCheck(S, Mersenne, quot, res)==0) {
printf("DivCheck Failed\n");
return;
}
Copy(S,T);
LongRightShift(T, p);
t = p/16;
r = p - 16*t;
d = Degree(S);
for(k = d; k>t; k--){
S[k] = 0;
}
S[t] = (S[t]<<(32-r))>>(32-r);
Add(S, T);
k = Compare(S, Mersenne);
if(k==1 || k==0){
Sub(S, Mersenne);
}
k = Compare(res, S);
if(k!=0) {
printf("Something is wrong\n");
return;
}
}
if(ZeroCheck(S)==0) printf("mersenne, p = %d\n", p);
p = p+2;
p = NextPrime(p);
}
}
