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);
