char *test_new() { val1 = Array_new(array); mu_assert(val1 != NULL, "failed to make a new element"); val2 = Array_new(array); mu_assert(val2 != NULL, "failed to make a new element"); return NULL; }
NFA CopyNFA (NFA nfa) { int i, id, n; NFA copyNFA ; Status fromS, toS, s1, s2; Edge e, e_temp; copyNFA = malloc (sizeof (NFA)); assert (copyNFA); /* 首先,复制nfa状态数组中所有状态 */ n = Array_length (nfa->statusArray); copyNFA -> statusArray = Array_new (n, sizeOfStatus()); Array_copy_from_range (copyNFA->statusArray, 0, nfa->statusArray, 0, n); /* 第二步,复制所有边(除了指向前后Status的储存单元 */ n = Array_length (nfa->edgeArray); copyNFA -> edgeArray = Array_new (n, sizeOfEdge()); Array_copy_from_range (copyNFA->edgeArray, 0, nfa->edgeArray, 0, n); /* 第三部,针对edgeArray的每一条边,生成每个Status的InEdges和OutEdges */ for (i=0; i < Array_length (nfa->edgeArray); i++) { e = (Edge)Array_get (nfa->edgeArray, i); fromS = getfromStatus (e); toS = gettoStatus (e); e = Array_get (copyNFA->edgeArray, i); id = getStatusID (fromS); s1 = Array_get (copyNFA->statusArray, id); appendOutEdge (s1, i); id = getStatusID (toS); s2 = Array_get (copyNFA->statusArray, id); appendInEdge (s2, i); setFromToStatus (e, s1, s2); } /* 最后,更新start 和 end */ n = Array_length (copyNFA->statusArray); copyNFA -> start = Array_get (copyNFA->statusArray, 0); copyNFA -> end = Array_get (copyNFA->statusArray, n-1); ensureFinalStatus (copyNFA->end); return copyNFA; }
char *test_array_new() { a = Array_new(TEST_INIT_SIZE); test_assert(a != NULL, "Could not create new array\n"); return NULL; }
static void new_oneValue_sizeOneValue(void **state) { int theValue= 5; array_t array = Array_new(theValue); assert_int_equal(Array_getSize(array), theValue); Array_delete(array); }
void Array_byteShiftRight_(Array *self, int s) { Array *ba = Array_new(); Array_setLength_(ba, s); Array_removeFrom_to_(self, 0, s); Array_append_(self, ba); }
static void addEl_oneValue_FirstDataOneValue(void **state) { array_t array = Array_new(5); int theValue= 6; Array_addEl(array,theValue); assert_int_equal(Array_getEl(array,0), theValue); Array_delete(array); }
static void merge_hasTwoPushedValue_returnsMergedValuesAndSizeOfTwo(void **state) { int theValue= 1; array_t array1 = Array_new(theValue); array_t array2 = Array_new(theValue); int addedEl=6; Array_addEl(array1,addedEl); Array_addEl(array2,addedEl); array_t array3=Array_merge(array1, array2); assert_int_equal(Array_getSize(array3), theValue*2); int i; for(i=0;i<theValue*2;i++){ assert_int_equal(Array_getEl(array3,i), addedEl); } Array_delete(array1); Array_delete(array2); Array_delete(array3); }
static void setSize_oneValue_sizeOneValue(void **state) { int theValue1= 5; array_t array = Array_new(theValue1); int theValue2= 6; Array_setSize(array,theValue2); assert_int_equal(Array_getSize(array), theValue2); Array_delete(array); }
Array *Array_newWithData_size_copy_(uint8_t *bytes, size_t byteCount, int copy) { Array *self = Array_new(); Data_release(self->data); self->data = Data_newWithBytes_size_copy_(self->data, byteCount, copy); return self; }
Object * Hash_keys(Object *self) { GList *keys_list = g_hash_table_get_keys(as_hash(self)->hash); Object *keys = Array_new(); while (keys_list) { Array_push(keys, as_object(keys_list->data)); keys_list = keys_list->next; } return keys; }
Array Array_transpose(Array a) { Array aT; bool b; int i,j, src, target; size_t esize; void *aTdata, *adata; EXIT_ON_NULL(a, "Array_transpose") aT = Array_new( a->type ); if (a->ndims != 2) { fprintf(stderr, "Only 2D arrays can be transposed\n"); return aT; } b = Array_allocate(aT, a->length); if (!b) { fprintf(stderr, "Could not allocate space for transposed array"); return aT; } // flip dimensions aT->ndims = a->ndims; for (i=0; i < a->ndims; i++) { aT->dimsize[i] = a->dimsize[a->ndims-i-1]; } // copy attributes aT->length = a->length; aT->min = a->min; aT->max = a->max; aT->undef_value = a->undef_value; // transpose data aTdata = Array_getDataPointer(aT); adata = Array_getDataPointer(a); esize = arrayTypeElementSizes[a->type]; target = 0; //printf("%%%%%%%%%%%%%%%%%% TRANSPOSE %%%%%%%%%%%%%%%%%%\n"); //printf("esize = %d\n", esize); for (i=0; i < aT->dimsize[0]; i++) { for (j=0; j < aT->dimsize[1]; j++) { src = j*aT->dimsize[0] + i; // aT[i,j] = a[j,i] = a( j*M + i ), a=NxM, aT=MxN //printf("%d: src = %d\n", target, src); memcpy( aTdata + target*esize, adata + src*esize, esize); target++; } } return aT; }
NFA CreateNFA_without_edge() { NFA nfa ; nfa = malloc (sizeof (struct Automaton)); assert(nfa); /* 初始化唯一的两个状态点 */ nfa->start = nfa->end = allocStatus(); setStatusID (nfa->start, 1); ensureFinalStatus (nfa->start); /* 初始化nfa的Edge数组, 长度为0 */ nfa->edgeArray = Array_new (0, sizeOfEdge()); /* 初始化nfa的Status状态数组 */ nfa->statusArray = Array_new (1, sizeOfStatus()); Array_put (nfa->statusArray, 0, nfa->start); return nfa ; }
T Array_copy(T array, size_t length) { T copy; assert(array); //assert(length >= 0); copy = Array_new(length, array->size); if (copy->length >= array->length && array->length > 0) memcpy(copy->array, array->array, array->length*array->size); else if (array->length > copy->length && copy->length > 0) memcpy(copy->array, array->array, copy->length*array->size); return copy; }
void get_two_StatusSet_Table (NFA nfa, StatusSet_table *T, int inverse[]) { int i, j, id, n, curr_set_id, e_index; Edge e; Status s; Array_T StatusArray, edgeArray, OutEdges, closure; T->size = 0; StatusArray = getStatusArray (nfa); edgeArray = getEdgeArray (nfa); n = Array_length (StatusArray); /* 一开始所有状态不属于任一集合 */ for (i=0; i<n; i++) inverse[i] = -1; for (i=0; i<n; i++) { if (inverse[i] != -1) continue; /* 闭包缓存 */ curr_set_id = T->size; inverse[i] = curr_set_id; closure = Array_new (0, sizeof(int)); s = Array_get(StatusArray, i); getEpsilonClosure(s, nfa, closure, inverse, curr_set_id); for (j=0; j<Array_length(closure); j++) { id = *(int*)Array_get(closure, j); s = Array_get(nfa->statusArray, id); if (isFinalStatus(s)) T->H[T->size].hasFinalStatus = true; } /* 以s为原点进行DFS,找出所有epsilon闭包 * getEpsilonClosure(s, closure, inverse) */ T->H[T->size].epsClosure = closure; //printStatusSet(T->H[T->size]); //wprintf(L"-------------------------------\n"); T->size++; } }
T Array_copy(T array, int length) { T copy; assert(array); assert(length >= 0); copy = Array_new(length, array->size); if (copy->length >= array->length && array->length > 0) { memcpy(copy->array, array->array, array->length); } else if (array->length > copy->length && copy->length > 0) { memcpy(copy->array, array->array, copy->length); } return copy; }
char *test_arrays() { Object **contents = calloc(4, sizeof(Object*)); contents[0] = Integer_new(0); contents[1] = Integer_new(1); contents[2] = Integer_new(2); contents[3] = Integer_new(3); Object *object = Array_new(contents, 4); mu_assert(object->type == tArray, "Array has the wrong type"); DArray *array = (DArray*)object->value.other; Object *first = (Object*)DArray_at(array, 0); mu_assert(first->value.integer == 0, "Array element is wrong."); Object_destroy(object); free(contents); return NULL; }
char *test_push_pop() { int i = 0; for(i = 0; i < 1000; i++) { int *val = Array_new(array); *val = i * 333; Array_push(array, val); } mu_assert(array->max == 1201, "Wrong max size."); for(i = 999; i >= 0; i--) { int *val = Array_pop(array); mu_assert(val != NULL, "Shouldn't get a NULL."); mu_assert(*val == i * 333, "Wrong value."); Array_free(val); } return NULL; }
Array_T reach_Status (NFA nfa, StatusSet currSet, int inverse[], wchar_t c) { Array_T toSets; int from, to; toSets = Array_new(0,sizeof(int)); int i; for (i=0; i<Array_length(currSet.epsClosure); i++) { from = *(int*)Array_get(currSet.epsClosure, i); to = reachStatus(nfa, from, c); if (to!=-1) { Array_append(toSets, &inverse[to]); } } return toSets; }
Array_T getCharSet(NFA nfa) { int i; ULL128 v; ULL64 a = 1ULL; Edge e; wchar_t c; Array_T charSet; charSet = Array_new(0,sizeof(wchar_t)); setZero(&v); for (i=0; i<Array_length(nfa->edgeArray); i++) { e = Array_get(nfa->edgeArray, i); if (!isEpsilon(e)) { v = Or(getMatchBitVector(e), v); } } for (i=0; i<64; i++) { c = (wchar_t)i; if ((a & v.L64) != 0) Array_append (charSet, &c); a <<= 1; } a = 1ULL; for (i=0; i<64; i++) { c = (wchar_t)(i+64); if ((a & v.H64) != 0) Array_append (charSet, &c); a <<= 1; } return charSet; }
char *test_hashes() { Object **contents = calloc(4, sizeof(Object*)); contents[0] = String_new(bfromcstr("foo")); contents[1] = Integer_new(1); contents[2] = String_new(bfromcstr("bar")); contents[3] = Integer_new(2); Object *array = Array_new(contents, 4); Object *object = Hash_new(array); mu_assert(object->type == tHash, "Hash has the wrong type"); Hashmap *map = (Hashmap*)object->value.other; Object *foo = (Object*)Hashmap_get(map, contents[0]); mu_assert(foo->value.integer == 1, "Hash element 'foo' is wrong."); Object *bar = (Object*)Hashmap_get(map, contents[2]); mu_assert(bar->value.integer == 2, "Hash element 'bar' is wrong."); Object_destroy(object); Object_destroy(array); free(contents); return NULL; }
void Player_beginner2_think(Player* player, Othello* othello, int* x, int* y, BOOL* isResign){ // 最もたくさんの数が取れる場所に打つ Evaluation eval; PointList list; Othello_moveList(othello, &list); if(list.length > 0){ eval = Player_beginner2_search(player, othello, &list, 5); *x = list.x[eval.index]; *y = list.y[eval.index]; *isResign = FALSE; } else{ *isResign = TRUE; } { Array int_array; int temp; int temp_out; int i; Array_new(&int_array, 5, sizeof(int)); temp = 0; Array_append(&int_array, &temp); temp = 1; Array_append(&int_array, &temp); temp = 2; Array_append(&int_array, &temp); temp = 3; Array_append(&int_array, &temp); temp = 4; Array_append(&int_array, &temp); temp = 5; Array_append(&int_array, &temp); for(i = 0; i < Array_length(&int_array); i++){ temp_out = *(int*)Array_get(&int_array, i); } Array_delete(&int_array); } }
void Array_byteShiftLeft_(Array *self, int s) { Array *ba = Array_new(); Array_setLength_(ba, s); Array_insert_at_(self, ba, 0); }
#include "Irq.h" Array *IrqDesc_Set = Array_new(256);
#include "Ipc.h" Array *Ipc_Buffer_Set = Array_new(256); Array *Ipc_Tag_Set = Array_new(256);