void *xrealloc (void *ptr, size_t bytes) #endif { void *cp; MALLOC_CHECK(); #ifdef _DEBUG if (!ptr) cp = _malloc_dbg(bytes?bytes:1,_NORMAL_BLOCK,file,line); else cp = _realloc_dbg(ptr, bytes,_NORMAL_BLOCK,file,line); #else if (!ptr) cp = malloc (bytes?bytes:1); else cp = realloc(ptr, bytes); #endif if (cp == NULL) { char buf[80]; sprintf (buf, "out of memory; can not reallocate %lu bytes", (unsigned long) bytes); error (1, 0, buf); } MALLOC_CHECK(); return (cp); }
void *xmalloc (size_t bytes) #endif { void *cp; /* Parts of CVS try to xmalloc zero bytes and then free it. Some systems have a malloc which returns NULL for zero byte allocations but a free which can't handle NULL, so compensate. */ if (bytes == 0) bytes = 1; MALLOC_CHECK(); #ifdef _DEBUG cp = _malloc_dbg(bytes,_NORMAL_BLOCK,file,line); #else cp = malloc (bytes); #endif if (cp == NULL) { char buf[80]; sprintf (buf, "out of memory; can not allocate %lu bytes", (unsigned long) bytes); error (1, 0, buf); } MALLOC_CHECK(); return (cp); }
list_node *add_list_node(list_node *head, void *pdata, size_t len) { list_node *last_node, *new_node; /* create new head */ if (head->data == NULL) { head->data = malloc(len); MALLOC_CHECK(head->data); memcpy(head->data, pdata, len); new_node = head; } else { last_node = head; while (last_node->next) last_node = last_node->next; new_node = (list_node *) calloc(1, sizeof(list_node)); MALLOC_CHECK(new_node); new_node->data = malloc(len); MALLOC_CHECK(new_node->data); memcpy(new_node->data, pdata, len); /* link in new node */ last_node->next = new_node; } return new_node; }
//tries to add an entry into the dictionary void DAdd(void* data, char* key){ int num = hash(key); if (dict->start == NULL){//first element; dictionary empty MYASSERT(dict->end == NULL); dict->start = dict->end = (DNODE *)NEW(DNODE); MALLOC_CHECK(dict->start); dict->start->prev = dict->start->next = NULL; dict->hash[num] = dict->start; dict->start->data = data; BZERO(dict->start->key, KEY_LENGTH); strncpy(dict->start->key, key, KEY_LENGTH); } else{ DNODE *d; if (dict->hash[num] == NULL){//non-collision case d = NEW(DNODE); dict->hash[num] = d; d->next = NULL; d->prev = dict->end; dict->end->next = d; dict->end = d; BZERO(d->key, KEY_LENGTH); strncpy(d->key, key, KEY_LENGTH); d->data = data; } else {//collision case int unique = TRUE; DNODE *temp = dict->hash[num]; //as long as the hashes are the same, keep going while (hash(temp->key) == num){ //check for matches if (strncmp(temp->key, key, MAX_URL_LENGTH) == 0) unique = FALSE; if (temp->next == NULL || unique == FALSE) break;//reached the end or we know it's not unique temp = temp->next; } //only add if we didn't find the url in the list if (unique == TRUE){ temp = temp->prev; DNODE *d = NEW(DNODE); MALLOC_CHECK(d); d->next = temp->next; d->prev = temp; if (d->next == NULL)//for the case that hash[num] is at the end dict->end = d; else temp->next->prev = d; temp->next = d; BZERO(d->key, KEY_LENGTH); strncpy(d->key, key, KEY_LENGTH); d->data = data; } } } }
// tweaked version of update index to insert an element into the index along with with the frequency int insertElementIntoIndex(char* word, int documentId, int frequency, INVERTED_INDEX* index) { int hashIndex = hash1(word)%MAX_HASH_SLOT; // something is in there already if ((index->hash[hashIndex]) != NULL) { DocumentNode* init; init = (index->hash[hashIndex])->page; if(init->document_id == documentId) { init->page_word_frequency = frequency; (index->hash[hashIndex])->page = init; } else { DocumentNode* d; if(index->hash[hashIndex]) { int flag = 0; d = (index->hash[hashIndex])->page; while ((d->next) != NULL) { d = d->next; if(d->document_id == documentId) { //we found the same documentId d->page_word_frequency = frequency; flag = 1; break; } } if (flag == 0) { // documentId not present DocumentNode* dd = (DocumentNode*)malloc(sizeof(DocumentNode)); MALLOC_CHECK(dd); dd->next = NULL; dd->document_id = documentId; dd->page_word_frequency = frequency; if (d->next == NULL) { d->next = dd; } } } } return 1; } // nothing is in there already else { DocumentNode* doc = malloc(sizeof(DocumentNode)); MALLOC_CHECK(doc); doc->document_id = documentId; doc->page_word_frequency = frequency; doc->next = NULL; // add element into the index IndexAdd(index, (void*)doc, word); return 1; } }
char * digsyl(int range, int width) { int i, base = 1, target; static char *new_dig = NULL; static int last_width = 0; if (range <= 0 || width < 0) return(NULL); if (width == 0) { base=1;width=1; while(base <= range/10) { width++; base *= 10 ; } } else { for (i=0; i < width - 1; i++) base *= 10; } if (new_dig == NULL) { new_dig = (char *)malloc(sizeof(char) * SYL_WIDTH * width + 1); MALLOC_CHECK(new_dig); last_width = width; } else { new_dig[0] = '\0'; if (last_width < width) { new_dig = (char *)realloc(new_dig, width * sizeof(char) * SYL_WIDTH + 1); MALLOC_CHECK(new_dig); last_width = width; } } for (i=0; i < width * SYL_WIDTH; i += SYL_WIDTH) { target = range - (range % base); target /= base; strcpy(new_dig + i, digsyllables[target % 10]); range -= base * target; base /= 10; } return(new_dig); }
// TODO: move to util interp_workspace *new_interp_workspace(int upsample_ratio, interp_stats *stats) { interp_workspace *w = (interp_workspace *)malloc(sizeof(interp_workspace)); MALLOC_CHECK(w); w->input = gsl_vector_alloc(NUM_STENCIL_POINTS); MALLOC_CHECK(w->input); w->output = gsl_vector_alloc((upsample_ratio+1)*(upsample_ratio+1)); MALLOC_CHECK(w->output); w->stats = stats; return w; }
/* Automatically null the pointer after freeing it */ void xfree_s(void **ptr) { MALLOC_CHECK(); if(*ptr) { free(*ptr); MALLOC_CHECK(); } *ptr=NULL; }
/* * Routine: ProcessNames * Purpose: Parse the name vector * Algorithm: * Data Structures: * * Params: * Returns: * Called By: * Calls: * Assumptions: * Side Effects: * TODO: None */ int ProcessNames (char *stmt, token_t * tokens) { char *szResult = NULL; char *cp; int nCount = 0, nWordLength = 0; /* get the names */ while ((cp = strtok (NULL, "=( ,);:")) != NULL) { if (nCount == 0) { nWordLength = strlen(cp); szResult = malloc(nWordLength + 1); MALLOC_CHECK(szResult); nCount = nWordLength + 1; strcpy(szResult, cp); } else { nWordLength = strlen(cp); szResult = realloc(szResult, nCount + nWordLength + 1); strcpy(szResult + nCount, cp); nCount += nWordLength + 1; } } pCurrentIndexEntry->dist->names = szResult; return (nCount); }
// Function to write the webpage to a file. int WriteFile(WebPage *wp, char *path, int pageID) { // Declare and initialize a filename variable. char *filename = (char *)malloc(20); MALLOC_CHECK(stderr,filename); // Write to the filename variable. if (sprintf(filename, "%s/%d", path, pageID) == EOF) { printf("There is an error with the directory path.\n"); return 0; } // Declare and open a filepath with the filename. FILE *fp; fp = fopen(filename, "w+"); // Open a new file by the filename. // Check that there were no errors opening the file. if (fp == NULL) { printf("Error reading file.\n"); return 0; } // Write to each file of an html. fprintf(fp, "%s\n%d\n%s", wp->url, wp->depth, wp->html); // Cleanup. fclose(fp); free(filename); return 1; }
//takes in an array of search terms, gets the docID, score, and which list it should be added in //and passes the information to the function addScoreToList to be added to the list // //PSEUDO CODE //for all searchterms // get the docIDs associated with the word and add the score to the list but factor in a WEIGHT // if the prev searchterm is not OR // add to list with weight // else // add to the list void processSearchTerms(INVERTED_INDEX* index, char* searchterms) { int docID; int score; char* prevterm = NULL; char* currentterm; int pos; DOCNODE* d; while (searchterms != NULL) { currentterm = searchterms; pos = 0; if(isSearchTerm(currentterm) == TRUE) { //if it's a search term, normalize it and search for it NormalizeWord(currentterm); while((d = getDoc(index, currentterm, &pos)) != NULL) { docID = d->doc_id; score = d->page_word_freq; if(isNotOR(prevterm) == TRUE) { //add with weighteded score because it must be ADD addScoreToList(querylist, TRUE, docID, (score*WEIGHT)); } else//add with regular score addScoreToList(querylist, FALSE, docID, score); } } prevterm = currentterm; searchterms = strtok(NULL, " "); //get next searchterm } if (querylist->start != NULL) { slist = NEW(SORTLIST); MALLOC_CHECK(slist); BZERO(slist, sizeof(SORTLIST)); sortList(slist, querylist); printList(slist); } }
/* * re-set default output file names */ int set_files (int i, int pload) { char line[80], *new_name; if (table & (1 << i)) child_table: { if (pload != -1) sprintf (line, "%s.%d", tdefs[i].name, pload); else { printf ("Enter new destination for %s data: ", tdefs[i].name); if (fgets (line, sizeof (line), stdin) == NULL) return (-1);; if ((new_name = strchr (line, '\n')) != NULL) *new_name = '\0'; if (strlen (line) == 0) return (0); } new_name = (char *) malloc (strlen (line) + 1); MALLOC_CHECK (new_name); strcpy (new_name, line); tdefs[i].name = new_name; if (tdefs[i].child != NONE) { i = tdefs[i].child; tdefs[i].child = NONE; goto child_table; } } return (0); }
long * permute_dist(distribution *d, long stream) { static distribution *dist = NULL; int i; if (d != NULL) { if (d->permute == (long *)NULL) { d->permute = (long *)malloc(sizeof(long) * (DIST_SIZE(d))); MALLOC_CHECK(d->permute); for (i=0; i < (DIST_SIZE(d)); i++) *(d->permute + i) = i; } dist = d; return(permute(dist->permute, DIST_SIZE(dist), stream)); } if (dist != NULL) return(permute(NULL, DIST_SIZE(dist), stream)); else INTERNAL_ERROR("Bad call to permute_dist"); }
/* * Routine: MakePermutation(int nSize) * Purpose: Permute the integers in [1..nSize] * Algorithm: * Data Structures: * * Params: * Returns: * Called By: * Calls: * Assumptions: * Side Effects: * TODO: None */ int * makePermutation(int *nNumberSet, int nSize, int nStream) { int i, nTemp, nIndex, *pInt; if (nSize <= 0) return(NULL); if (!nNumberSet) { nNumberSet = (int *)malloc(nSize * sizeof(int)); MALLOC_CHECK(nNumberSet); pInt = nNumberSet; for (i=0; i < nSize; i++) *pInt++ = i; } for (i=0; i < nSize; i++) { nIndex = genrand_integer(NULL, DIST_UNIFORM, 0, nSize - 1, 0, nStream); nTemp = nNumberSet[i]; nNumberSet[i] = nNumberSet[nIndex]; nNumberSet[nIndex] = nTemp; } return(nNumberSet); }
//initializes the querylist void initQueryList() { querylist = NEW(QUERYLIST); MALLOC_CHECK(querylist); BZERO(querylist, sizeof(QUERYLIST)); querylist->start = querylist->end = NULL; for (int i = 0; i < MAX_HASH_SLOT; i++) querylist->hash[i] = NULL; }
int getopt(int ac, char **av, char *opt) { static char *nextchar = NULL; char *cp; char hold; if (optarg == NULL) { optarg = (char *)malloc(BUFSIZ); MALLOC_CHECK(optarg); } if (!nextchar || *nextchar == '\0') { optind++; if (optind == ac) return(-1); nextchar = av[optind]; if (*nextchar != '-') return(-1); nextchar +=1; } if (nextchar && *nextchar == '-') /* -- termination */ { optind++; return(-1); } else /* found an option */ { cp = strchr(opt, *nextchar); nextchar += 1; if (cp == NULL) /* not defined for this run */ return('?'); if (*(cp + 1) == ':') /* option takes an argument */ { if (*nextchar) { hold = *cp; cp = optarg; while (*nextchar) *cp++ = *nextchar++; *cp = '\0'; *cp = hold; } else /* white space separated, use next arg */ { if (++optind == ac) return('?'); strcpy(optarg, av[optind]); } nextchar = NULL; } return(*cp); } }
// initializes the index INVERTED_INDEX* InitIndex() { INVERTED_INDEX* index = (INVERTED_INDEX*)malloc(sizeof(INVERTED_INDEX)); MALLOC_CHECK(index); index->start = index->end = NULL; for (int i = 0; i< MAX_HASH_SLOT; i++) { index->hash[i] = NULL; } return index; }
DocumentNode *DNode(int docID, int freq) { DocumentNode *node = (DocumentNode *)calloc(1, sizeof(DocumentNode)); MALLOC_CHECK(stderr, node); node->next = NULL; node->docID = docID; node->freq = freq; return node; }
// updateIndex takes a word, a document_id, and an index. It adds the document to the index, // and the word itself if it's not already contained in the index. Returns 0 if success, 1 if failure. int updateIndex(char* word, int document_id, INVERTED_INDEX* in_index) { DocumentNode* docnode; WordNode* wordnode; DocumentNode* current_doc_node; int page_node_exists; page_node_exists = 0; // creates a DocumentNode from the doc_id docnode = malloc(sizeof(DocumentNode)); MALLOC_CHECK(docnode); docnode->document_id = document_id; docnode->page_word_frequency = 1; docnode->next = NULL; // makes it lower case (necessary for the query system) NormalizeWord(word); if(addData(in_index, docnode, word)) // if the wordnode already exists { wordnode = getData(in_index, word); if(wordnode != NULL) { current_doc_node = wordnode->data; while(current_doc_node != NULL) { if((current_doc_node->document_id) == document_id) { page_node_exists = 1; current_doc_node->page_word_frequency = (current_doc_node->page_word_frequency)+1; free(docnode); break; } else if(current_doc_node->next == NULL) break; else current_doc_node = current_doc_node->next; } if(!page_node_exists) { current_doc_node->next = docnode; } } } return 0; }
WordNode *WNode(DocumentNode *docNode, char *word) { WordNode *wordNode = (WordNode *)calloc(1, sizeof(WordNode)); MALLOC_CHECK(stderr, wordNode); //wordNode->next = NULL; wordNode->page = docNode; wordNode->word = (char *)calloc(strlen(word) + 1, sizeof(char)); // null terminator strcpy(wordNode->word, word); return wordNode; }
//takes in QUERYLIST and adds a QUERYNODE //to the ANDORLIST if the docID is unique, or updates the score of th QUERYNODE containing //the docID if the docID already exists in the list void addScoreToList(QUERYLIST* querylist, int isAND, int docID, int score) { char ID[DOCLEN]; sprintf(ID, "%d", docID); int num = hash(ID); QUERYNODE* l = querylist->hash[num]; int addNew = TRUE; while(1) { if (l == NULL) break; if (strncmp(ID, l->docID, DOCLEN) == 0) { addNew = FALSE; break; } else if (l->next == NULL || hash(l->docID) != num) break; l = l->next; } if (addNew == TRUE) { QUERYNODE* ll = NEW(QUERYNODE); MALLOC_CHECK(ll); BZERO(ll, sizeof(QUERYNODE)); ll->score = score; strncpy(ll->docID, ID, DOCLEN); if (querylist->start == NULL) { //first node case querylist->start = querylist->end = ll; ll->next = ll->prev = NULL; } else if (l != NULL && l->next != NULL) { //this and the next are collision cases ll->prev = l; ll->next = l->next; l->next->prev = ll; l->next = ll; } else if (l != NULL) { ll->prev = querylist->end; ll->next = NULL; querylist->end = ll; } else { //inserting into new hash slot querylist->hash[num] = ll; ll->prev = querylist->end; ll->next = NULL; querylist->end->next = ll; querylist->end = ll; } } else l->score = score + l->score; }
bit_array_t *upsample(double **grid, int ny, int nx, double alpha, int M, int upsample_ratio, interp_stats *stats) { gsl_matrix *interp = create_interp_matrix(alpha, M, upsample_ratio); bit_array_t *upsampled = new_bit_array((ny-1)*upsample_ratio+1, (nx-1)*upsample_ratio+1); MALLOC_CHECK(upsampled); int r,c,x,y; interp_workspace *w = new_interp_workspace(upsample_ratio, stats); for (r = 0 ; r < ny - 3 ; r++) { for (c = 0 ; c < nx - 3 ; c++) { interpolate(grid, upsampled, r, c, ny, nx, upsample_ratio, interp, w); } } free_interp_workspace(w); return upsampled; }
//initializes the dictionary DICTIONARY* initDict(){ DICTIONARY* dict = NEW(DICTIONARY); MALLOC_CHECK(dict); BZERO(dict, sizeof(DICTIONARY)); //dict->start = dict->end = malloc(sizeof(DNODE)); //MALLOC_CHECK(dict->start); //dict->start->prev = dict->start->next = NULL; dict->start = dict->end = NULL; for (int i = 0; i < MAX_HASH_SLOT; i++) dict->hash[i] = NULL; return dict; }
DocumentNode *addDocNode(int DocId, int frequency){ //create Document Node DocumentNode *dNew; dNew = (DocumentNode *)malloc(sizeof(DocumentNode)); MALLOC_CHECK(dNew); BZERO(dNew,sizeof(DocumentNode)); //update Document Node dNew->document_id = DocId; dNew->page_word_frequency = frequency; //return the new DocNode return dNew; }
// //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ // int srt_server_sock(unsigned int port) { //malloc new TCB entry at first NULL entry int sockfd = 0; while (sockfd < MAX_TRANSPORT_CONNECTIONS){ if (server_TCB_Table[sockfd] == NULL) { //malloc new client tcb entry server_TCB_Table[sockfd] = malloc(sizeof(svr_tcb_t)); MALLOC_CHECK(server_TCB_Table[sockfd]); memset(server_TCB_Table[sockfd], 0, sizeof(svr_tcb_t)); //initialize TCB entry, malloc recv buffer and mutex server_TCB_Table[sockfd]->svr_portNum = port; server_TCB_Table[sockfd]->state = CLOSED; server_TCB_Table[sockfd]->usedBufLen = 0; server_TCB_Table[sockfd]->expect_seqNum = 0; server_TCB_Table[sockfd]->recvBuf = malloc(RECEIVE_BUF_SIZE); memset(server_TCB_Table[sockfd]->recvBuf, 0, RECEIVE_BUF_SIZE); server_TCB_Table[sockfd]->bufMutex = malloc(sizeof(pthread_mutex_t)); memset(server_TCB_Table[sockfd]->bufMutex, 0, sizeof(pthread_mutex_t)); server_TCB_Table[sockfd]->svr_nodeID = topology_getMyNodeID(); printf("My nodeID is %u.\n", server_TCB_Table[sockfd]->svr_nodeID); //initialize mutex if (pthread_mutex_init(server_TCB_Table[sockfd]->bufMutex, NULL) != 0) { printf("\n mutex init failed\n"); return -1; } break; } else { sockfd++; } } if (sockfd == MAX_TRANSPORT_CONNECTIONS) { printf("You've reached the maximum number of transport connections.\n"); return -1; } else { printf("Created new TCB server entry with sockfd %d.\n", sockfd); return sockfd; } }
/* * Routine: * Purpose: * Algorithm: * Data Structures: * * Params: * Returns: * Called By: * Calls: * Assumptions: * Side Effects: * TODO: None */ substitution_t * findSubstitution(template_t *t, char *name, int *nUse) { int nChars, nUseCount; substitution_t *pSub; static substitution_t tempSubstitution; static int bInit = 0; if (!bInit) { memset(&tempSubstitution, 0, sizeof(struct SUBSTITUTION_T)); tempSubstitution.name = malloc(100 * sizeof(char)); MALLOC_CHECK(tempSubstitution.name); bInit = 1; } /* exclude any numeric suffix from search, but update nUses */ nChars = strcspn(name, "0123456789"); if (strlen(name) > 100) tempSubstitution.name = realloc(tempSubstitution.name, strlen(name) + 1); strncpy(tempSubstitution.name, name, nChars); tempSubstitution.name[nChars] = '\0'; pSub = findList(t->SubstitutionList, (void *)&tempSubstitution); if (!pSub) /* the substitution could be global; add a local reference */ { pSub = findList(g_Template->SubstitutionList, (void *)&tempSubstitution); if (pSub) addList(t->SubstitutionList, pSub); } if (pSub) { nUseCount = atoi(name + nChars); if (nUseCount == 0) nUseCount = 1; if (nUseCount > pSub->nUse) pSub->nUse = nUseCount; if (nUse) /* we're interested in the usage number */ *nUse = nUseCount; return(pSub); } return(NULL); }
/* * Routine: expr_t *makeExpr(void) * Purpose: * Algorithm: * Data Structures: * * Params: * Returns: * Called By: * Calls: * Assumptions: * Side Effects: * TODO: None */ expr_t * makeExpr(void) { expr_t *pResult; pResult = (expr_t *)malloc(sizeof(struct EXPR_T)); MALLOC_CHECK(pResult); if (pResult == NULL) ReportError(QERR_NO_MEMORY, "in MakeReplacement()", 1); memset(pResult, 0, sizeof(struct EXPR_T)); pResult->nValueCount = 1; #ifdef MEM_TEST fprintf(stderr, "MakeExpr value %x\n", pResult); #endif pResult->Value.pBuf = InitBuffer(10, 10); if (pResult->Value.pBuf == NULL) ReportError(QERR_NO_MEMORY, "in MakeReplacement()", 1); return(pResult); }
int TestgetWord1(){ START_TEST_CASE; char string[] = ""; char *result; int pos = 0; result = (char *)malloc(1000); MALLOC_CHECK(result); BZERO(result,1000); pos = getWord(string,result,pos); SHOULD_BE( pos == -1 ); SHOULD_BE( strcmp(result,"") == 0); free(result); END_TEST_CASE; }
long * permute_dist(distribution *d, long stream, DSS_HUGE& source, distribution* cd) { static bool bInit = false; static distribution *dist = NULL; if (d != NULL) { if (d->permute == (long *)NULL) { d->permute = (long *)malloc(sizeof(long) * DIST_SIZE(d)); MALLOC_CHECK(d->permute); //IP: permute does the same //for (int i=0; i < DIST_SIZE(d); i++) { // *(d->permute + i) = i; //} } while (!bInit) { dist = d; bInit = true; } // IP: This will not work in general, but afaict from the code // this function (permute_dist) is called only by mk_part // so 'dist' will never have to change its value. // This assertion ensures that 'dist' will have a single // value. assert (dist == d); return (permute(dist->permute, DIST_SIZE(dist), stream, source, cd->permute)); } if (dist != NULL) { return (permute(NULL, DIST_SIZE(dist), stream, source, cd->permute)); } else { INTERNAL_ERROR("Bad call to permute_dist"); } return (NULL); }
bit_array_t *createScaledMaskFromBilliard(Billiard *b, double xl, double xh, double yl, double yh, double dx, double upsample_ratio, double scale, int ny, int nx) { int nx_should_be, ny_should_be; if (xh - xl == 0.0) { ny_should_be = ceil((b->yh - b->yl + 0.9) / dx) * upsample_ratio + 1; nx_should_be = ceil((b->xh - b->xl + 0.9) / dx) * upsample_ratio + 1; } else { ny_should_be = (int)((yh - yl) / dx + 0.9) * upsample_ratio + 1; nx_should_be = (int)((xh - xl) / dx + 0.9) * upsample_ratio + 1; } if ((float)fabs(nx-nx_should_be)/nx_should_be > DIMENSION_ERROR_MARGIN || (float)fabs(ny-ny_should_be)/ny_should_be > DIMENSION_ERROR_MARGIN) { ERROR("Mask dimensions do not match expected dimesnions. Given %d x %d, expected %d x %d", ny, nx, ny_should_be, nx_should_be); exit(DIMENSION_ERR); } bit_array_t *counted = new_bit_array(ny, nx); MALLOC_CHECK(counted); int i, j; for (i = 0 ; i < ny ; i++) { for (j = 0 ; j < nx ; j++) { if (i == 0 || j == 0) { bit_array_set(counted, j, i); // mask out first row and column } if (!inside_billiard(j * (dx / upsample_ratio) / scale, i * (dx / upsample_ratio) / scale, b)) { bit_array_set(counted, j, i); // bit array is zeroed when allocated } } } // special case for qugrs billiard: mask out the two points at the tip if (b->type == QU_GEN_RECT_SINAI) { bit_array_set(counted, nx-1, ny-1); bit_array_set(counted, nx-2, ny-2); } return counted; }