Make the array type a tiny bit smaller, by packing control information into a bit array

1 files changed, 261 insertions, 261 deletions

diff --git a/functions.c b/functions.c
index 7c49554..9eb444e 100644
--- a/functions.c
+++ b/functions.c
@@ -322,14 +322,14 @@ fnNaturalLog(Array *right)
 Array *
 fnMatrixInverse(Array *right)
 {
-	if(right->type != AtypeInt && right->type != AtypeFloat)
+	if(GetType(right) != AtypeInt && GetType(right) != AtypeFloat)
 		throwerror(nil, EType);
-	if(right->rank > 2)
+	if(GetRank(right) > 2)
 		throwerror(nil, ERank);
 	
-	if(right->rank == 0)
+	if(GetRank(right) == 0)
 		return rundfn(L"⌹1 1⍴⍵", nil, nil, nil, right);
-	if(right->rank == 1)
+	if(GetRank(right) == 1)
 		return rundfn(L"⌹(1⍪⍨⍴⍵)⍴⍵", nil, nil, nil, right);
 
 	throwerror(L"Matrix inverse", ENotImplemented);
@@ -349,13 +349,13 @@ Array *
 fnFactorial(Array *right)
 {
 	Array *result = nil;
-	if(right->type == AtypeArray){
+	if(GetType(right) == AtypeArray){
 		result = duparrayshape(right, AtypeArray);
-		for(int i = 0; i < right->size; i++)
+		for(int i = 0; i < GetSize(right); i++)
 			result->arraydata[i] = fnFactorial(right->arraydata[i]);
-	}else if(right->type == AtypeInt){
+	}else if(GetType(right) == AtypeInt){
 		result = duparrayshape(right, AtypeFloat);
-		for(int i = 0; i < result->size; i++){
+		for(int i = 0; i < GetSize(result); i++){
 			double x = 1;
 			vlong n = right->intdata[i];
 			if(n < 0)
@@ -364,7 +364,7 @@ fnFactorial(Array *right)
 				x *= j;
 			result->floatdata[i] = x;
 		}
-	}else if(right->type == AtypeFloat)
+	}else if(GetType(right) == AtypeFloat)
 		throwerror(L"Factorial of floating values", ENotImplemented);
 	else
 		throwerror(nil, EType);
@@ -375,23 +375,23 @@ Array *
 fnRoll(Array *right)
 {
 	Array *result = nil;
-	if(right->type == AtypeArray){
+	if(GetType(right) == AtypeArray){
 		result = duparrayshape(right, AtypeArray);
-		for(int i = 0; i < right->size; i++)
+		for(int i = 0; i < GetSize(right); i++)
 			result->arraydata[i] = fnRoll(right->arraydata[i]);
-	}else if(right->type == AtypeInt){
-		if(right->size == 0)
+	}else if(GetType(right) == AtypeInt){
+		if(GetSize(right) == 0)
 			return duparrayshape(right, AtypeInt);
 		int io = globalIO();
 		vlong lowest = right->intdata[0];
-		for(int i = 1; i < right->size; i++)
+		for(int i = 1; i < GetSize(right); i++)
 			if(right->intdata[i] < lowest)
 				lowest = right->intdata[i];
 		if(lowest < 0)
 			throwerror(nil, EDomain);
 		else if(lowest == 0){
 			result = duparrayshape(right, AtypeFloat);
-			for(int i = 0; i < right->size; i++){
+			for(int i = 0; i < GetSize(right); i++){
 				vlong max = right->intdata[i];
 				if(max == 0)
 					do{
@@ -402,7 +402,7 @@ fnRoll(Array *right)
 			}
 		}else{
 			result = duparrayshape(right, AtypeInt);
-			for(int i = 0; i < right->size; i++)
+			for(int i = 0; i < GetSize(right); i++)
 				result->intdata[i] = io + lrand() % right->intdata[i];
 		}
 	}else
@@ -426,18 +426,18 @@ Array *
 fnFloor(Array *right)
 {
 	Array *res = nil;
-	switch(right->type){
+	switch(GetType(right)){
 	case AtypeInt:
 		res = fnSame(right);
 		break;
 	case AtypeFloat:
 		res = duparrayshape(right, AtypeInt);
-		for(int i = 0; i < right->size; i++)
+		for(int i = 0; i < GetSize(right); i++)
 			res->intdata[i] = floor(right->floatdata[i]);
 		break;
 	case AtypeArray:
 		res = duparrayshape(right, AtypeArray);
-		for(int i = 0; i < right->size; i++)
+		for(int i = 0; i < GetSize(right); i++)
 			res->arraydata[i] = fnFloor(right->arraydata[i]);
 		break;
 	default:
@@ -456,13 +456,13 @@ fnSame(Array *right)
 Array *
 fnUniqueMask(Array *right)
 {
-	if(right->rank == 0){
+	if(GetRank(right) == 0){
 		Array *res = allocarray(AtypeInt, 1, 1);
 		res->shape[0] = 1;
 		res->intdata[0] = 1;
 		return res;
 	}
-	if(right->size == 0){
+	if(GetSize(right) == 0){
 		Array *res = allocarray(AtypeInt, 1, 0);
 		res->shape[0] = 0;
 		return res;
@@ -484,47 +484,47 @@ fnDepth(Array *right)
 Array *
 fnTally(Array *right)
 {
-	return mkscalarint(right->rank==0 ? 1 : right->shape[0]);
+	return mkscalarint(GetRank(right)==0 ? 1 : right->shape[0]);
 }
 
 Array *
 fnMix(Array *right)
 {
-	if(right->type != AtypeArray || right->size == 0)
+	if(GetType(right) != AtypeArray || GetSize(right) == 0)
 		return fnSame(right);
 
 	int commonrank = 0;
 	int i,j;
-	for(i = 0; i < right->size; i++)
-		if(right->arraydata[i]->rank > commonrank)
-			commonrank = right->arraydata[i]->rank;
+	for(i = 0; i < GetSize(right); i++)
+		if(GetRank(right->arraydata[i]) > commonrank)
+			commonrank = GetRank(right->arraydata[i]);
 
 	Array *commonshape = allocarray(AtypeInt, 1, commonrank);
 	commonshape->shape[0] = commonrank;
 	for(i = 0; i < commonrank; i++)
 		commonshape->intdata[i] = 0;
 
-	for(i = 0; i < right->size; i++){
+	for(i = 0; i < GetSize(right); i++){
 		Array *a = right->arraydata[i];
-		for(j = 0; j < a->rank; j++){
-			if(a->shape[a->rank-1-j] > commonshape->intdata[commonrank-1-j])
-				commonshape->intdata[commonrank-1-j] = a->shape[a->rank-1-j];
+		for(j = 0; j < GetRank(a); j++){
+			if(a->shape[GetRank(a)-1-j] > commonshape->intdata[commonrank-1-j])
+				commonshape->intdata[commonrank-1-j] = a->shape[GetRank(a)-1-j];
 		}
 	}
 
 	int size = 1;
 	int commonsize = 1;
-	for(i = 0; i < right->rank; i++)
+	for(i = 0; i < GetRank(right); i++)
 		size *= right->shape[i];
-	for(i = 0; i < commonshape->size; i++){
+	for(i = 0; i < GetSize(commonshape); i++){
 		size *= commonshape->intdata[i];
 		commonsize *= commonshape->intdata[i];
 	}
 
-	Array *result = allocarray(AtypeArray, right->rank + commonrank, size);
-	for(i = 0; i < right->rank; i++)
+	Array *result = allocarray(AtypeArray, GetRank(right) + commonrank, size);
+	for(i = 0; i < GetRank(right); i++)
 		result->shape[i] = right->shape[i];
-	for(j = 0; j < commonshape->size; j++)
+	for(j = 0; j < GetSize(commonshape); j++)
 		result->shape[i+j] = commonshape->intdata[j];
 
 	int *index = emalloc(sizeof(int) * commonrank);
@@ -532,8 +532,8 @@ fnMix(Array *right)
 	for(i = 0; i < size/commonsize; i++){
 		Array *a = right->arraydata[i];
 		Array *fill = fillelement(a);
-		if(a->rank == 0){
-			if(a->type == AtypeArray)
+		if(GetRank(a) == 0){
+			if(GetType(a) == AtypeArray)
 				result->arraydata[i*commonsize] = a->arraydata[0];
 			else
 				result->arraydata[i*commonsize] = a;
@@ -546,8 +546,8 @@ fnMix(Array *right)
 			for(j = 0; j < commonrank; j++)
 				index[j] = 0;
 			for(j = 0, offset = 0; offset < commonsize; j++){
-				for(int k = 0; index[commonrank-1-k] == a->shape[a->rank-1-k]; k++){
-					int nfill = commonshape->intdata[commonrank-1-k] - a->shape[a->rank-1-k];
+				for(int k = 0; index[commonrank-1-k] == a->shape[GetRank(a)-1-k]; k++){
+					int nfill = commonshape->intdata[commonrank-1-k] - a->shape[GetRank(a)-1-k];
 					while(nfill--){
 						result->arraydata[i*commonsize+offset] = fill;
 						incarrayref(fill);
@@ -556,7 +556,7 @@ fnMix(Array *right)
 					index[commonrank-1-k] = 0;
 					index[commonrank-2-k]++;
 				}
-				if(j < a->size){
+				if(j < GetSize(a)){
 					result->arraydata[i*commonsize+offset] = arrayitem(a, j);
 					offset++;
 					index[commonrank-1]++;
@@ -597,7 +597,7 @@ fnEnclose(Array *right)
 Array *
 fnDisclose(Array *right)
 {
-	if(right->size == 0)
+	if(GetSize(right) == 0)
 		return fillelement(right);
 	else
 		return arrayitem(right, 0);
@@ -615,7 +615,7 @@ fnNest(Array *right)
 Array *
 fnGradeUp(Array *right)
 {
-	if(right->rank == 0)
+	if(GetRank(right) == 0)
 		throwerror(nil, ERank);
 
 	int i,j;
@@ -664,7 +664,7 @@ Array *
 fnIndexGenerator(Array *right)
 {
 	Array *result = nil;
-	if(right->rank == 0){
+	if(GetRank(right) == 0){
 		vlong n = right->intdata[0];
 		if(n < 0)
 			throwerror(nil, EDomain);
@@ -673,8 +673,8 @@ fnIndexGenerator(Array *right)
 		vlong io = globalIO();
 		for(vlong i = 0; i < n; i++)
 			result->intdata[i] = i + io;
-	}else if(right->rank == 1){
-		if(right->size == 0)
+	}else if(GetRank(right) == 1){
+		if(GetSize(right) == 0)
 			return rundfn(L"⊂⍬", nil, nil, nil, nil);
 		else
 			result = rundfn(L"⊃⍣(0<≢⍵),⌾⌿⍳¨⍵", nil, nil, nil, right);
@@ -692,13 +692,13 @@ fnWhere(Array *right)
 Array *
 fnEnlist(Array *right)
 {
-	if(right->size == 0)
+	if(GetSize(right) == 0)
 		return fnSame(right);
-	if(right->type != AtypeArray)
+	if(GetType(right) != AtypeArray)
 		return fnRavel(right);
 	else{
 		Array *res = fnEnlist(right->arraydata[0]);
-		for(int i = 1; i < right->size; i++){
+		for(int i = 1; i < GetSize(right); i++){
 			Array *old = res;
 			Array *tmp = fnEnlist(right->arraydata[i]);
 			res = fnCatenateFirst(res, tmp);
@@ -712,7 +712,7 @@ fnEnlist(Array *right)
 Array *
 fnUnique(Array *right)
 {
-	if(right->rank == 0)
+	if(GetRank(right) == 0)
 		return fnRavel(right);
 
 	return rundfn(L"(≠⍵)⌿⍵", nil, nil, nil, right);
@@ -721,10 +721,10 @@ fnUnique(Array *right)
 Array *
 fnNot(Array *right)
 {
-	if(right->type != AtypeInt)
+	if(GetType(right) != AtypeInt)
 		throwerror(nil, EType);
 	Array *res = duparray(right);
-	for(int i = 0; i < res->size; i++){
+	for(int i = 0; i < GetSize(res); i++){
 		if(res->intdata[i] == 0)
 			res->intdata[i] = 1;
 		else if(res->intdata[i] == 1)
@@ -741,9 +741,9 @@ Array *
 fnRavel(Array *right)
 {
 	Array *res = duparray(right);
-	res->rank = 1;
-	res->shape = erealloc(res->shape, sizeof(int) * 1);
-	res->shape[0] = res->size;
+	SetRank(res, 1);
+	res->shape = erealloc(res->shape, sizeof(*res->shape) * 1);
+	res->shape[0] = GetSize(res);
 	return res;
 }
 
@@ -751,19 +751,19 @@ Array *
 fnTable(Array *right)
 {
 	Array *res = duparray(right);
-	res->rank = 2;
-	res->shape = erealloc(res->shape, sizeof(int) * 2);
-	res->shape[0] = right->rank ? res->shape[0] : 1;
-	res->shape[1] = right->size / res->shape[0];
+	SetRank(res, 2);
+	res->shape = erealloc(res->shape, sizeof(*res->shape) * 2);
+	res->shape[0] = GetRank(right) ? res->shape[0] : 1;
+	res->shape[1] = GetSize(right) / res->shape[0];
 	return res;
 }
 
 Array *
 fnShape(Array *right)
 {
-	Array *res = allocarray(AtypeInt, 1, right->rank);
-	res->shape[0] = right->rank;
-	for(int i = 0; i < right->rank; i++)
+	Array *res = allocarray(AtypeInt, 1, GetRank(right));
+	res->shape[0] = GetRank(right);
+	for(int i = 0; i < GetRank(right); i++)
 		res->intdata[i] = right->shape[i];
 	return res;
 }
@@ -771,22 +771,22 @@ fnShape(Array *right)
 Array *
 fnReverseLast(Array *right)
 {
-	if(right->rank < 1)
+	if(GetRank(right) < 1)
 		return fnSame(right);
 
 	Array *res = duparray(right);
 
 	int nrows = 1;
-	int rowsize = res->shape[res->rank-1];
-	for(int i = 0; i < res->rank - 1; i++)
+	int rowsize = res->shape[GetRank(res)-1];
+	for(int i = 0; i < GetRank(res) - 1; i++)
 		nrows *= res->shape[i];
 
 	for(int row = 0; row < nrows; row++){
 		for(int i = 0; i < rowsize; i++)
 			memcpy(
-				res->rawdata + (row * rowsize + i) * datasizes[res->type],
-				right->rawdata + ((1+row) * rowsize - 1 - i) * datasizes[res->type],
-				datasizes[res->type]);
+				res->rawdata + (row * rowsize + i) * datasizes[GetType(res)],
+				right->rawdata + ((1+row) * rowsize - 1 - i) * datasizes[GetType(res)],
+				datasizes[GetType(res)]);
 	}
 	return res;
 }
@@ -794,17 +794,17 @@ fnReverseLast(Array *right)
 Array *
 fnReverseFirst(Array *right)
 {
-	if(right->rank < 1 || right->shape[0] == 0)
+	if(GetRank(right) < 1 || right->shape[0] == 0)
 		return fnSame(right);
 
 	Array *res = duparray(right);
 	int cells = res->shape[0];
-	int elems = res->size / cells;
+	int elems = GetSize(res) / cells;
 	for(int i = 0; i < cells; i++)
 		memcpy(
-			res->rawdata + i * elems * datasizes[res->type],
-			right->rawdata + (cells - 1 - i) * elems * datasizes[res->type],
-			datasizes[res->type] * elems);
+			res->rawdata + i * elems * datasizes[GetType(res)],
+			right->rawdata + (cells - 1 - i) * elems * datasizes[GetType(res)],
+			datasizes[GetType(res)] * elems);
 	return res;
 }
 
@@ -812,31 +812,31 @@ Array *
 fnTranspose(Array *right)
 {
 	Array *res = duparray(right);
-	for(int i = 0; i < res->rank; i++)
-		res->shape[i] = right->shape[res->rank - 1 - i];
+	for(int i = 0; i < GetRank(res); i++)
+		res->shape[i] = right->shape[GetRank(res) - 1 - i];
 
 	int from, to;
-	int *sizesFrom = emalloc(sizeof(int) * right->rank);
-	int *sizesTo = emalloc(sizeof(int) * right->rank);
+	int *sizesFrom = emalloc(sizeof(int) * GetRank(right));
+	int *sizesTo = emalloc(sizeof(int) * GetRank(right));
 	int accFrom = 1, accTo = 1;
-	for(int i = 0; i < right->rank; i++){
+	for(int i = 0; i < GetRank(right); i++){
 		sizesFrom[i] = accFrom;
 		sizesTo[i] = accTo;
 		accFrom *= res->shape[i];
 		accTo *= right->shape[i];
 	}
 
-	for(from = 0; from < right->size; from++){
+	for(from = 0; from < GetSize(right); from++){
 		to = 0;
 		int tmp = from;
-		for(int i = right->rank-1; i >= 0; i--){
-			to += sizesTo[right->rank-1-i] * (tmp / sizesFrom[i]);
+		for(int i = GetRank(right)-1; i >= 0; i--){
+			to += sizesTo[GetRank(right)-1-i] * (tmp / sizesFrom[i]);
 			tmp = tmp % sizesFrom[i];
 		}
 		memcpy(
-			res->rawdata + to * datasizes[res->type],
-			right->rawdata + from * datasizes[res->type],
-			datasizes[res->type]);
+			res->rawdata + to * datasizes[GetType(res)],
+			right->rawdata + from * datasizes[GetType(res)],
+			datasizes[GetType(res)]);
 	}
 	free(sizesFrom);
 	free(sizesTo);
@@ -846,7 +846,7 @@ fnTranspose(Array *right)
 Array *
 fnExecute(Array *right)
 {
-	if(right->type != AtypeRune)
+	if(GetType(right) != AtypeRune)
 		throwerror(nil, EType);
 	Rune *code = pparray(right);
 	Datum *result = evalline(code, nil, 1);
@@ -863,11 +863,11 @@ fnExecute(Array *right)
 Array *
 fnFormat(Array *right)
 {
-	if(right->type == AtypeArray)
+	if(GetType(right) == AtypeArray)
 		throwerror(L"Format for nested arrays", ENotImplemented);
 	/* TODO add support for formatting nested arrays */
 
-	right = right->rank == 0 ? fnRavel(right) : fnSame(right);
+	right = GetRank(right) == 0 ? fnRavel(right) : fnSame(right);
 
 	Rune *str = pparray(right);
 	int maxwidth = 0;
@@ -882,14 +882,14 @@ fnFormat(Array *right)
 		}
 	}
 	vlong size;
-	if(right->shape[right->rank-1] == 0)
+	if(right->shape[GetRank(right)-1] == 0)
 		size = 0;
 	else
-		size = maxwidth * right->size / right->shape[right->rank-1];
+		size = maxwidth * GetSize(right) / right->shape[GetRank(right)-1];
 
-	Array *result = allocarray(AtypeRune, right->rank, size);
-	result->shape[result->rank-1] = maxwidth;
-	for(int i = 0; i < result->rank-1; i++)
+	Array *result = allocarray(AtypeRune, GetRank(right), size);
+	result->shape[GetRank(result)-1] = maxwidth;
+	for(int i = 0; i < GetRank(result)-1; i++)
 		result->shape[i] = right->shape[i];
 	int offset = 0;
 	for(int i = 0; str[i] != 0; i++)
@@ -918,7 +918,7 @@ fnSelfReference1(Array *right)
 #define SCALAR_FUNCTION_2(name, forcefloat, restype, cases) \
 Array *name(Array *left, Array *right){\
 	Array *leftarr, *rightarr;\
-	int nested = left->type == AtypeArray || right->type == AtypeArray;\
+	int nested = GetType(left) == AtypeArray || GetType(right) == AtypeArray;\
 	if(nested){\
 		leftarr = fnSame(left);\
 		rightarr = fnSame(right);\
@@ -930,7 +930,7 @@ Array *name(Array *left, Array *right){\
 	Array *res;\
 	if(nested){\
 		res = duparrayshape(left, AtypeArray);\
-		for(int i = 0; i < left->size; i++){\
+		for(int i = 0; i < GetSize(left); i++){\
 			Array *l = arrayitem(left, i);\
 			Array *r = arrayitem(right, i);\
 			res->arraydata[i] = name(l,r);\
@@ -939,8 +939,8 @@ Array *name(Array *left, Array *right){\
 		}\
 	}else{\
 		res = duparray(left);\
-		for(int i = 0; i < left->size; i++)\
-			switch(left->type){\
+		for(int i = 0; i < GetSize(left); i++)\
+			switch(GetType(left)){\
 			default: throwerror(nil, EType); break;\
 			cases\
 			}\
@@ -948,7 +948,7 @@ Array *name(Array *left, Array *right){\
 	freearray(leftarr); freearray(rightarr); freearray(left); freearray(right);\
 	return res;}
 
-SCALAR_FUNCTION_2(fnPlus, 0, left->type,
+SCALAR_FUNCTION_2(fnPlus, 0, GetType(left),
 	case AtypeFloat:
 		res->floatdata[i] += right->floatdata[i];
 		break;
@@ -957,7 +957,7 @@ SCALAR_FUNCTION_2(fnPlus, 0, left->type,
 		break;
 )
 
-SCALAR_FUNCTION_2(fnMinus, 0, left->type,
+SCALAR_FUNCTION_2(fnMinus, 0, GetType(left),
 	case AtypeFloat:
 		res->floatdata[i] -= right->floatdata[i];
 		break;
@@ -966,7 +966,7 @@ SCALAR_FUNCTION_2(fnMinus, 0, left->type,
 		break;
 )
 
-SCALAR_FUNCTION_2(fnTimes, 0, left->type,
+SCALAR_FUNCTION_2(fnTimes, 0, GetType(left),
 	case AtypeFloat:
 		res->floatdata[i] *= right->floatdata[i];
 		break;
@@ -975,7 +975,7 @@ SCALAR_FUNCTION_2(fnTimes, 0, left->type,
 		break;
 )
 
-SCALAR_FUNCTION_2(fnDivide, 1, left->type,
+SCALAR_FUNCTION_2(fnDivide, 1, GetType(left),
 	case AtypeFloat:
 		if(right->floatdata[i] == 0){
 			if(globalDIV())
@@ -988,7 +988,7 @@ SCALAR_FUNCTION_2(fnDivide, 1, left->type,
 		break;
 )
 
-SCALAR_FUNCTION_2(fnPower, 0, left->type,
+SCALAR_FUNCTION_2(fnPower, 0, GetType(left),
 	case AtypeFloat:
 		res->floatdata[i] = pow(res->floatdata[i], right->floatdata[i]);
 		break;
@@ -997,7 +997,7 @@ SCALAR_FUNCTION_2(fnPower, 0, left->type,
 		break;
 )
 
-SCALAR_FUNCTION_2(fnLogarithm, 1, left->type,
+SCALAR_FUNCTION_2(fnLogarithm, 1, GetType(left),
 	case AtypeFloat:
 		res->floatdata[i] = log(right->floatdata[i])/log(res->floatdata[i]);
 		break;
@@ -1075,9 +1075,9 @@ SCALAR_FUNCTION_2(fnBinomial, 0, AtypeFloat,
 Array *
 fnDeal(Array *left, Array *right)
 {
-	if(left->type != AtypeInt || right->type != AtypeInt)
+	if(GetType(left) != AtypeInt || GetType(right) != AtypeInt)
 		throwerror(nil, EType);
-	if(left->size != 1 || right->size != 1)
+	if(GetSize(left) != 1 || GetSize(right) != 1)
 		throwerror(nil, EShape);
 	vlong x = left->intdata[0];
 	vlong y = right->intdata[0];
@@ -1098,7 +1098,7 @@ fnDeal(Array *left, Array *right)
 	return result;
 }
 
-SCALAR_FUNCTION_2(fnResidue, 1, left->type,
+SCALAR_FUNCTION_2(fnResidue, 1, GetType(left),
 	case AtypeFloat:
 		if(res->floatdata[i] == 0)
 			res->floatdata[i] = right->floatdata[i];
@@ -1106,7 +1106,7 @@ SCALAR_FUNCTION_2(fnResidue, 1, left->type,
 			res->floatdata[i] = right->floatdata[i] - res->floatdata[i] * floor(right->floatdata[i]/res->floatdata[i]);
 )
 
-SCALAR_FUNCTION_2(fnMaximum, 0, left->type,
+SCALAR_FUNCTION_2(fnMaximum, 0, GetType(left),
 	case AtypeFloat:
 		if(res->floatdata[i] < right->floatdata[i])
 			res->floatdata[i] = right->floatdata[i];
@@ -1115,7 +1115,7 @@ SCALAR_FUNCTION_2(fnMaximum, 0, left->type,
 			res->intdata[i] = right->intdata[i];		
 )
 
-SCALAR_FUNCTION_2(fnMinimum, 0, left->type,
+SCALAR_FUNCTION_2(fnMinimum, 0, GetType(left),
 	case AtypeFloat:
 		if(res->floatdata[i] > right->floatdata[i])
 			res->floatdata[i] = right->floatdata[i];
@@ -1127,9 +1127,9 @@ SCALAR_FUNCTION_2(fnMinimum, 0, left->type,
 Array *
 fnDecode(Array *left, Array *right)
 {
-	if(left->type != AtypeInt && left->type != AtypeFloat)
+	if(GetType(left) != AtypeInt && GetType(left) != AtypeFloat)
 		throwerror(nil, EType);
-	if(right->type != AtypeInt && right->type != AtypeFloat)
+	if(GetType(right) != AtypeInt && GetType(right) != AtypeFloat)
 		throwerror(nil, EType);
 	return rundfn(L"(⌽×\\1,⌽⍵∘{1↓(≢⍺)⍴⍵}⍤1⊢⍺)+.×⍵", nil, nil, left, right);
 }
@@ -1137,12 +1137,12 @@ fnDecode(Array *left, Array *right)
 Array *
 fnEncode(Array *left, Array *right)
 {
-	if(left->type != AtypeInt && left->type != AtypeFloat)
+	if(GetType(left) != AtypeInt && GetType(left) != AtypeFloat)
 		throwerror(nil, EType);
-	if(right->type != AtypeInt && right->type != AtypeFloat)
+	if(GetType(right) != AtypeInt && GetType(right) != AtypeFloat)
 		throwerror(nil, EType);
 
-	if(left->rank > 1)
+	if(GetRank(left) > 1)
 		return rundfn(L"⍉(⍉⍺) (⊤⍤1) ⍵", nil, nil, left, right);
 	else
 		return rundfn(L"⎕div←1 ⋄ ((⍴⍺),⍴⍵)⍴(⌽⍺){0=≢⍺:⍬ ⋄ n←⊃⍺ ⋄ x←n|⍵ ⋄ ((1↓⍺)∇n÷⍨⍵-x)⍪x}⍵", nil, nil, left, right);
@@ -1231,7 +1231,7 @@ fnMatch(Array *left, Array *right)
 	return mkscalarint(cmp == 0);
 }
 
-SCALAR_FUNCTION_2(fnOr, 0, left->type,
+SCALAR_FUNCTION_2(fnOr, 0, GetType(left),
 	case AtypeInt:
 		if((left->intdata[i] == 0 || left->intdata[i] == 1) && (right->intdata[i] == 0 || right->intdata[i] == 1))
 			res->intdata[i] = left->intdata[i] || right->intdata[i];
@@ -1243,7 +1243,7 @@ SCALAR_FUNCTION_2(fnOr, 0, left->type,
 		break;
 )
 
-SCALAR_FUNCTION_2(fnAnd, 0, left->type,
+SCALAR_FUNCTION_2(fnAnd, 0, GetType(left),
 	case AtypeInt:
 		if((left->intdata[i] == 0 || left->intdata[i] == 1) && (right->intdata[i] == 0 || right->intdata[i] == 1))
 			res->intdata[i] = left->intdata[i] && right->intdata[i];
@@ -1283,81 +1283,81 @@ Array *
 fnTake(Array *left, Array *right)
 {
 	int i;
-	if(left->type != AtypeInt)
+	if(GetType(left) != AtypeInt)
 		throwerror(nil, EType);
-	if(left->rank > 1)
+	if(GetRank(left) > 1)
 		throwerror(nil, ERank);
 
-	if(right->rank == 0){
+	if(GetRank(right) == 0){
 		right = duparray(right);
-		right->rank = left->size;
-		right->shape = erealloc(right->shape, sizeof(int) * right->rank);
-		for(i = 0; i < right->rank; i++)
+		SetRank(right, GetSize(left));
+		right->shape = erealloc(right->shape, sizeof(*right->shape) * GetRank(right));
+		for(i = 0; i < GetRank(right); i++)
 			right->shape[i] = 1;
 	}else
 		right = fnSame(right);
 
-	if(left->size > right->rank)
+	if(GetSize(left) > GetRank(right))
 		throwerror(nil, ELength);
-	else if(left->size == right->rank)
+	else if(GetSize(left) == GetRank(right))
 		left = fnSame(left);
 	else{
 		Array *old = left;
 		left = fnShape(right);
-		for(i = 0; i < old->size; i++)
+		for(i = 0; i < GetSize(old); i++)
 			left->intdata[i] = old->intdata[i];
 	}
 
-	int *shape = emalloc(sizeof(int) * left->size);
+	int *shape = emalloc(sizeof(int) * GetSize(left));
 	int size = 1;
-	for(i = 0; i < left->size; i++){
+	for(i = 0; i < GetSize(left); i++){
 		int s = left->intdata[i];
 		shape[i] = s < 0 ? -s : s;
 		size *= shape[i];
 	}
 
 	Array *fill = fillelement(right);
-	Array *result = allocarray(right->type, right->rank, size);
-	for(i = 0; i < right->rank; i++)
+	Array *result = allocarray(GetType(right), GetRank(right), size);
+	for(i = 0; i < GetRank(right); i++)
 		result->shape[i] = shape[i];
 
-	int *index = emallocz(sizeof(int) * left->size, 1);
+	int *index = emallocz(sizeof(int) * GetSize(left), 1);
 	int fromindex;
 	for(i = 0; i < size; i++){
-		for(int j = left->size-1; index[j] == shape[j]; j--){
+		for(int j = GetSize(left)-1; index[j] == shape[j]; j--){
 			index[j] = 0;
 			index[j-1]++;
 		}
 
 		int inside = 1;
 		fromindex = 0;
-		for(int j = 0; j < left->size && inside; j++){
+		for(int j = 0; j < GetSize(left) && inside; j++){
 			vlong n = left->intdata[j];
 			vlong m = index[j];
 			if(n > 0 && m >= right->shape[j])
 				inside = 0;
-			else if(n < 0 && m < ((-n)-right->shape[j]))
+			else if(n < 0 && m < (vlong)((-n)-right->shape[j]))
 				inside = 0;
 			int add;
 			if(n < 0)
 				add = n + index[j] + right->shape[j];
 			else
 				add = index[j];
-			for(int k = j+1; k < right->rank; k++)
+			for(int k = j+1; k < GetRank(right); k++)
 				add *= right->shape[k];
 			fromindex += add;
 		}
 
 		if(inside)
-			memcpy(result->rawdata + i*datasizes[result->type],
-				right->rawdata + fromindex*datasizes[result->type],
-				datasizes[result->type]);
+			memcpy(result->rawdata + i*datasizes[GetType(result)],
+				right->rawdata + fromindex*datasizes[GetType(result)],
+				datasizes[GetType(result)]);
 		else
-			memcpy(result->rawdata + i*datasizes[result->type],
-				fill->rawdata, datasizes[result->type]);
-		if(result->type == AtypeArray)
+			memcpy(result->rawdata + i*datasizes[GetType(result)],
+				fill->rawdata, datasizes[GetType(result)]);
+		if(GetType(result) == AtypeArray)
 			incarrayref(result->arraydata[i]);
-		index[left->size-1]++;
+		index[GetSize(left)-1]++;
 	}
 
 	free(shape);
@@ -1372,34 +1372,34 @@ Array *
 fnDrop(Array *left, Array *right)
 {
 	int i;
-	if(left->type != AtypeInt)
+	if(GetType(left) != AtypeInt)
 		throwerror(nil, EType);
-	if(left->rank > 1)
+	if(GetRank(left) > 1)
 		throwerror(nil, ERank);
 
-	if(right->rank == 0){
+	if(GetRank(right) == 0){
 		right = duparray(right);
-		right->rank = left->size;
-		right->shape = erealloc(right->shape, sizeof(int) * right->rank);
-		for(i = 0; i < right->rank; i++)
+		SetRank(right, GetSize(left));
+		right->shape = erealloc(right->shape, sizeof(*right->shape) * GetRank(right));
+		for(i = 0; i < GetRank(right); i++)
 			right->shape[i] = 1;
 	}else
 		right = fnSame(right);
 
-	if(left->size > right->rank)
+	if(GetSize(left) > GetRank(right))
 		throwerror(nil, ELength);
-	else if(left->size == right->rank)
+	else if(GetSize(left) == GetRank(right))
 		left = fnSame(left);
 	else{
 		Array *old = left;
-		left = allocarray(AtypeInt, 1, right->rank);
-		left->shape[0] = left->size;
-		for(i = 0; i < old->size; i++)
+		left = allocarray(AtypeInt, 1, GetRank(right));
+		left->shape[0] = GetSize(left);
+		for(i = 0; i < GetSize(old); i++)
 			left->intdata[i] = old->intdata[i];
-		for(; i < left->size; i++)
+		for(; i < GetSize(left); i++)
 			left->intdata[i] = 0;
 	}
-	for(int i = 0; i < left->size; i++){
+	for(int i = 0; i < GetSize(left); i++){
 		vlong n = left->intdata[i];
 		vlong m = right->shape[i];
 		if(n > m || (-n) > m)
@@ -1418,27 +1418,27 @@ fnDrop(Array *left, Array *right)
 Array *
 fnPick(Array *left, Array *right)
 {
-	if(left->rank > 1)
+	if(GetRank(left) > 1)
 		throwerror(nil, ERank);
-	if(left->size == 0)
+	if(GetSize(left) == 0)
 		return fnSame(right);
 
 	int io = globalIO();
 	Array *result = fnSame(right);
-	for(int i = 0; i < left->size; i++){
+	for(int i = 0; i < GetSize(left); i++){
 		Array *ix = arrayitem(left, i);
-		if(ix->rank > 1)
+		if(GetRank(ix) > 1)
 			throwerror(nil, ERank);
-		if(ix->size != result->rank)
+		if(GetSize(ix) != GetRank(result))
 			throwerror(nil, ERank);
 		int index = 0;
-		for(int j = 0; j < ix->size; j++){
+		for(int j = 0; j < GetSize(ix); j++){
 			int add = ix->intdata[j] - io;
-			for(int k = j+1; k < ix->size; k++)
+			for(int k = j+1; k < GetSize(ix); k++)
 				add *= result->shape[k];
 			index += add;
 		}
-		if(index >= result->size)
+		if(index >= GetSize(result))
 			throwerror(nil, EIndex);
 		Array *tmp = result;
 		result = arrayitem(result, index);
@@ -1450,13 +1450,13 @@ fnPick(Array *left, Array *right)
 Array *
 fnPartition(Array *left, Array *right)
 {
-	if(right->rank == 0)
+	if(GetRank(right) == 0)
 		throwerror(nil, ERank);
-	if(left->rank > 2)
+	if(GetRank(left) > 2)
 		throwerror(nil, ERank);
-	if(left->type != AtypeInt)
+	if(GetType(left) != AtypeInt)
 		throwerror(nil, EType);
-	if(left->size != right->shape[0])
+	if(GetSize(left) != right->shape[0])
 		throwerror(nil, ELength);
 	if(right->shape[0] == 0)
 		return fnSame(right); /* TODO figure out if this is correct */
@@ -1469,8 +1469,8 @@ fnPartition(Array *left, Array *right)
 	int start = -1;
 	int io = globalIO();
 	int active = 0;
-	for(i = 0; i <= left->size; i++){
-		vlong n = i == left->size ? 0 : left->intdata[i];
+	for(i = 0; i <= GetSize(left); i++){
+		vlong n = i == GetSize(left) ? 0 : left->intdata[i];
 		if(n < 0)
 			throwerror(nil, EDomain);
 		if(active && (n == 0 || n > prev)){
@@ -1505,31 +1505,31 @@ fnIndex(Array *left, Array *right)
 	int io = globalIO();
 	int i;
 
-	if(left->rank > 1)
+	if(GetRank(left) > 1)
 		throwerror(nil, ERank);
-	if(left->type != AtypeArray && left->type != AtypeInt)
+	if(GetType(left) != AtypeArray && GetType(left) != AtypeInt)
 		throwerror(nil, EType);
-	if(left->size > right->rank)
+	if(GetSize(left) > GetRank(right))
 		throwerror(nil, ELength);
 
 	/* extend left index vector to full format */
 	Array *oldleft = left;
-	left = allocarray(AtypeArray, 1, right->rank);
-	left->shape[0] = right->rank;
-	for(i = 0; i < left->size; i++){
-		if(i >= oldleft->size){
+	left = allocarray(AtypeArray, 1, GetRank(right));
+	left->shape[0] = GetRank(right);
+	for(i = 0; i < GetSize(left); i++){
+		if(i >= GetSize(oldleft)){
 			Array *n = mkscalarint(right->shape[i]);
 			left->arraydata[i] = fnIndexGenerator(n);
 			freearray(n);
-		}else if(oldleft->type == AtypeInt){
+		}else if(GetType(oldleft) == AtypeInt){
 			if(oldleft->intdata[i] < io || oldleft->intdata[i] >= io + right->shape[i])
 				throwerror(nil, EIndex);
 			left->arraydata[i] = mkscalarint(oldleft->intdata[i]);
-		}else if(oldleft->type == AtypeArray){
+		}else if(GetType(oldleft) == AtypeArray){
 			Array *sub = oldleft->arraydata[i];
-			if(sub->type != AtypeInt)
+			if(GetType(sub) != AtypeInt)
 				throwerror(nil, EType);
-			for(int j = 0; j < sub->size; j++){
+			for(int j = 0; j < GetSize(sub); j++){
 				if(sub->intdata[j] < io || sub->intdata[j] >= io + right->shape[i])
 					throwerror(nil, EIndex);
 			}
@@ -1543,8 +1543,8 @@ fnIndex(Array *left, Array *right)
 
 	int rank = 0;
 	int size = 1;
-	for(i = 0; i < left->size; i++){
-		if(left->type == AtypeArray){
+	for(i = 0; i < GetSize(left); i++){
+		if(GetType(left) == AtypeArray){
 			Array *tmp = shape;
 			Array *newShape = fnShape(left->arraydata[i]);
 			shape = fnCatenateFirst(tmp, newShape);
@@ -1553,34 +1553,34 @@ fnIndex(Array *left, Array *right)
 		}
 	}
 
-	for(i = 0; i < shape->size; i++){
+	for(i = 0; i < GetSize(shape); i++){
 		size *= shape->intdata[i];
 		rank++;
 	}
 
-	Array *result = allocarray(right->type, rank, size);
+	Array *result = allocarray(GetType(right), rank, size);
 	for(i = 0; i < rank; i++)
 		result->shape[i] = shape->intdata[i];
 	freearray(shape);
-	int *leftindex = emallocz(sizeof(int) * right->rank, 1);
-	for(i = 0; i < result->size; i++){
-		for(int j = left->size-1; leftindex[j] == left->arraydata[j]->size; j--){
+	int *leftindex = emallocz(sizeof(int) * GetRank(right), 1);
+	for(i = 0; i < GetSize(result); i++){
+		for(int j = GetSize(left)-1; leftindex[j] == GetSize(left->arraydata[j]); j--){
 			leftindex[j] = 0;
 			leftindex[j-1]++;
 		}
 		int from = 0;
-		int cellsize = right->size;
-		for(int j = 0; j < left->size; j++){
+		int cellsize = GetSize(right);
+		for(int j = 0; j < GetSize(left); j++){
 			cellsize = cellsize / right->shape[j];
 			from += cellsize * (left->arraydata[j]->intdata[leftindex[j]] - io);
 		}
 		memcpy(
-			result->rawdata + i * datasizes[result->type],
-			right->rawdata + from * datasizes[result->type],
-			datasizes[result->type]);
-		if(result->type == AtypeArray)
+			result->rawdata + i * datasizes[GetType(result)],
+			right->rawdata + from * datasizes[GetType(result)],
+			datasizes[GetType(result)]);
+		if(GetType(result) == AtypeArray)
 			incarrayref(result->arraydata[i]);
-		leftindex[left->size-1]++;
+		leftindex[GetSize(left)-1]++;
 	}
 	free(leftindex);
 	freearray(left);
@@ -1602,10 +1602,10 @@ fnIntervalIndex(Array *left, Array *right)
 Array *
 fnMembership(Array *left, Array *right)
 {
-	if(right->size == 0)
+	if(GetSize(right) == 0)
 		return rundfn(L"(⍴⍵)⍴0", nil, nil, nil, left);
 
-	if(right->rank == 0)
+	if(GetRank(right) == 0)
 		return rundfn(L"⍺∊,⍵", nil, nil, left, right);
 	
 	/* TODO avoid outer product */
@@ -1616,20 +1616,20 @@ Array *
 fnFind(Array *left, Array *right)
 {
 	int i,j;
-	if(left->rank > right->rank){
+	if(GetRank(left) > GetRank(right)){
 		print("Left rank larger\n");
 		return rundfn(L"(⍴⍵)⍴0", nil, nil, nil, right);
 	}
 
-	if(left->rank < right->rank){
-		Array *newleft = allocarray(left->type, right->rank, left->size);
-		for(i = 0; i < right->rank - left->rank; i++)
+	if(GetRank(left) < GetRank(right)){
+		Array *newleft = allocarray(GetType(left), GetRank(right), GetSize(left));
+		for(i = 0; i < GetRank(right) - GetRank(left); i++)
 			newleft->shape[i] = 1;
-		for(j = 0; j < left->rank; j++)
+		for(j = 0; j < GetRank(left); j++)
 			newleft->shape[i+j] = left->shape[j]; 
-		memcpy(newleft->rawdata, left->rawdata, datasizes[left->type] * left->size);
-		if(left->type == AtypeArray)
-			for(i = 0; i < left->size; i++)
+		memcpy(newleft->rawdata, left->rawdata, datasizes[GetType(left)] * GetSize(left));
+		if(GetType(left) == AtypeArray)
+			for(i = 0; i < GetSize(left); i++)
 				incarrayref(newleft->arraydata[i]);
 		left = newleft;
 	}else
@@ -1642,7 +1642,7 @@ fnFind(Array *left, Array *right)
 Array *
 fnUnion(Array *left, Array *right)
 {
-	if(left->rank > 1 || right->rank > 1)
+	if(GetRank(left) > 1 || GetRank(right) > 1)
 		throwerror(nil, ERank);
 	return rundfn(L"⍺⍪⍵~⍺", nil, nil, left, right);
 }
@@ -1650,7 +1650,7 @@ fnUnion(Array *left, Array *right)
 Array *
 fnIntersection(Array *left, Array *right)
 {
-	if(left->rank > 1 || right->rank > 1)
+	if(GetRank(left) > 1 || GetRank(right) > 1)
 		throwerror(nil, ERank);
 	return rundfn(L"(⍺∊⍵)⌿⍺", nil, nil, left, right);
 }
@@ -1673,64 +1673,64 @@ fnCatenateFirst(Array *left, Array *right)
 	Array *leftarr = nil;
 	Array *rightarr = nil;
 
-	if(left->rank == 0 && right->rank != 0){
-		/* extend left to right->rank with first axis=1 */
+	if(GetRank(left) == 0 && GetRank(right) != 0){
+		/* extend left to GetRank(right) with first axis=1 */
 		rightarr = fnSame(right);
 		Array *shape = fnShape(right);
 		shape->intdata[0] = 1;
 		leftarr = fnReshape(shape, left);
 		freearray(shape);
-	}else if(left->rank != 0 && right->rank == 0){
-		/* extend right to left->rank with first axis=1 */
+	}else if(GetRank(left) != 0 && GetRank(right) == 0){
+		/* extend right to GetRank(left) with first axis=1 */
 		leftarr = fnSame(left);
 		Array *shape = fnShape(left);
 		shape->intdata[0] = 1;
 		rightarr = fnReshape(shape, right);
 		freearray(shape);
-	}else if(left->rank == 0 && right->rank == 0){
+	}else if(GetRank(left) == 0 && GetRank(right) == 0){
 		/* turn both scalars into vectors */
 		leftarr = fnRavel(left);
 		rightarr = fnRavel(right);
 	}else{
 		/* Check that the shapes match */
-		if(left->rank == right->rank-1){
+		if(GetRank(left) == GetRank(right)-1){
 			/* extend left with unit dimension */
-			Array *shape = allocarray(AtypeInt, 1, left->rank+1);
+			Array *shape = allocarray(AtypeInt, 1, GetRank(left)+1);
 			shape->intdata[0] = 1;
-			for(int i = 1; i < left->rank+1; i++)
+			for(int i = 1; i < GetRank(left)+1; i++)
 				shape->intdata[i] = left->shape[i-1];
 			leftarr = fnReshape(shape, left);
 			rightarr = fnSame(right);
 			freearray(shape);
-		}else if(right->rank == left->rank-1){
+		}else if(GetRank(right) == GetRank(left)-1){
 			/* extend right with unit dimension */
-			Array *shape = allocarray(AtypeInt, 1, right->rank+1);
+			Array *shape = allocarray(AtypeInt, 1, GetRank(right)+1);
 			shape->intdata[0] = 1;
-			for(int i = 1; i < right->rank+1; i++)
+			for(int i = 1; i < GetRank(right)+1; i++)
 				shape->intdata[i] = right->shape[i-1];
 			rightarr = fnReshape(shape, right);
 			leftarr = fnSame(left);
 			freearray(shape);
-		}else if(right->rank == left->rank){
+		}else if(GetRank(right) == GetRank(left)){
 			leftarr = fnSame(left);
 			rightarr = fnSame(right);
 		}else
 			throwerror(nil, ERank);
 
-		for(int i = 1; i < leftarr->rank; i++)
+		for(int i = 1; i < GetRank(leftarr); i++)
 			if(leftarr->shape[i] != rightarr->shape[i])
 				throwerror(nil, EShape);
 	}
 
 	int type, rank, leftsize, rightsize;
-	if(leftarr->type == AtypeArray || rightarr->type == AtypeArray || leftarr->type != rightarr->type)
+	if(GetType(leftarr) == AtypeArray || GetType(rightarr) == AtypeArray || GetType(leftarr) != GetType(rightarr))
 		type = AtypeArray;
 	else
-		type = leftarr->type;
-	if(leftarr->rank > rightarr->rank)
-		rank = leftarr->rank;
+		type = GetType(leftarr);
+	if(GetRank(leftarr) > GetRank(rightarr))
+		rank = GetRank(leftarr);
 	else
-		rank = rightarr->rank;
+		rank = GetRank(rightarr);
 	
 	leftsize = leftarr->shape[0];
 	rightsize = rightarr->shape[0];
@@ -1742,16 +1742,16 @@ fnCatenateFirst(Array *left, Array *right)
 	Array *result = allocarray(type, rank, leftsize + rightsize);
 	int i, j;
 	result->shape[0] = leftarr->shape[0] + rightarr->shape[0];
-	for(i = 1; i < result->rank; i++)
+	for(i = 1; i < GetRank(result); i++)
 		result->shape[i] = leftarr->shape[i];
 
 	/* TODO reduce duplicated code between copies from left and right */
 	/* Copy data from the left array */
-	for(i = 0, j = 0; i < leftarr->size; i++, j++){
-		if(type == AtypeArray && leftarr->type == AtypeArray){
+	for(i = 0, j = 0; i < GetSize(leftarr); i++, j++){
+		if(type == AtypeArray && GetType(leftarr) == AtypeArray){
 			result->arraydata[j] = leftarr->arraydata[i];
 			incarrayref(result->arraydata[j]);
-		}else if(type == AtypeArray && leftarr->type != AtypeArray){
+		}else if(type == AtypeArray && GetType(leftarr) != AtypeArray){
 			result->arraydata[j] = arrayitem(leftarr, i);
 		}else{
 			memcpy(
@@ -1762,11 +1762,11 @@ fnCatenateFirst(Array *left, Array *right)
 	}
 
 	/* Copy data from the right array */
-	for(i = 0; i < rightarr->size; i++, j++){
-		if(type == AtypeArray && rightarr->type == AtypeArray){
+	for(i = 0; i < GetSize(rightarr); i++, j++){
+		if(type == AtypeArray && GetType(rightarr) == AtypeArray){
 			result->arraydata[j] = rightarr->arraydata[i];
 			incarrayref(result->arraydata[j]);
-		}else if(type == AtypeArray && rightarr->type != AtypeArray){
+		}else if(type == AtypeArray && GetType(rightarr) != AtypeArray){
 			result->arraydata[j] = arrayitem(rightarr, i);
 		}else{
 			memcpy(
@@ -1787,18 +1787,18 @@ fnReshape(Array *left, Array *right)
 	vlong size = 1;
 	int i;
 	char *p;
-	for(i = 0; i < left->size; i++)
+	for(i = 0; i < GetSize(left); i++)
 		size *= left->intdata[i];
-	if(left->size == 0)
+	if(GetSize(left) == 0)
 		return arrayitem(right, 0);
 
-	Array *res = allocarray(right->type, left->size, size);
-	for(i = 0; i < left->size; i++)
+	Array *res = allocarray(GetType(right), GetSize(left), size);
+	for(i = 0; i < GetSize(left); i++)
 		res->shape[i] = left->intdata[i];
-	for(i = 0, p = res->rawdata; i < size; i++, p += datasizes[res->type])
-		memcpy(p, right->rawdata + (datasizes[res->type] * (i % right->size)), datasizes[res->type]);
-	if(res->type == AtypeArray)
-		for(i = 0; i < res->size; i++)
+	for(i = 0, p = res->rawdata; i < size; i++, p += datasizes[GetType(res)])
+		memcpy(p, right->rawdata + (datasizes[GetType(res)] * (i % GetSize(right))), datasizes[GetType(res)]);
+	if(GetType(res) == AtypeArray)
+		for(i = 0; i < GetSize(res); i++)
 			incarrayref(res->arraydata[i]);
 	return res;
 }
@@ -1812,43 +1812,43 @@ fnRotateLast(Array *left, Array *right)
 Array *
 fnRotateFirst(Array *left, Array *right)
 {
-	if(left->type != AtypeInt)
+	if(GetType(left) != AtypeInt)
 		throwerror(nil, EType);
 
-	if(right->rank == 0 || right->size < 2)
+	if(GetRank(right) == 0 || GetSize(right) < 2)
 		return fnSame(right);
 
 	int i, j;
-	if(left->size == 1 && right->rank != 0){
+	if(GetSize(left) == 1 && GetRank(right) != 0){
 		vlong v = left->intdata[0];
-		left = allocarray(AtypeInt, right->rank-1, right->size / right->shape[0]);
-		for(i = 0; i < left->rank; i++)
+		left = allocarray(AtypeInt, GetRank(right)-1, GetSize(right) / right->shape[0]);
+		for(i = 0; i < GetRank(left); i++)
 			left->shape[i] = right->shape[i+1];
-		for(i = 0; i < left->size; i++)
+		for(i = 0; i < GetSize(left); i++)
 			left->intdata[i] = v;
 	}else
 		left = fnSame(left);
 
-	if(left->rank != right->rank-1)
+	if(GetRank(left) != GetRank(right)-1)
 		throwerror(nil, ERank);
-	for(i = 0; i < left->rank; i++)
+	for(i = 0; i < GetRank(left); i++)
 		if(left->shape[i] != right->shape[i+1])
 			throwerror(nil, EShape);
 
 	int n = right->shape[0];
-	for(i = 0; i < left->size; i++)
+	for(i = 0; i < GetSize(left); i++)
 		while(left->intdata[i] < 0)
 			left->intdata[i] += n;
 
 	Array *result = duparray(right);
 	for(i = 0; i < n; i++){
-		for(j = 0; j < left->size; j++){
+		for(j = 0; j < GetSize(left); j++){
 			vlong rot = left->intdata[j];
-			vlong from = j + ((i+rot)%n)*left->size;
-			vlong to = j + i*left->size;
-			memcpy(result->rawdata + to*datasizes[right->type],
-				right->rawdata + from*datasizes[right->type],
-				datasizes[right->type]);
+			vlong from = j + ((i+rot)%n)*GetSize(left);
+			vlong to = j + i*GetSize(left);
+			memcpy(result->rawdata + to*datasizes[GetType(right)],
+				right->rawdata + from*datasizes[GetType(right)],
+				datasizes[GetType(right)]);
 		}
 	}
 	return result;
@@ -1869,9 +1869,9 @@ fnSelfReference2(Array *left, Array *right)
 Array *
 fnSend(Array *left, Array *right)
 {
-	if(right->size != 1)
+	if(GetSize(right) != 1)
 		throwerror(nil, ELength);
-	if(right->type != AtypeInt)
+	if(GetType(right) != AtypeInt)
 		throwerror(nil, EType);
 	messagesend(left, right->intdata[0]);
 	return fnSame(left);
@@ -1899,17 +1899,17 @@ gcd_float(double a, double b)
 Array *
 indexOfHelper(Array *left, Array *right, int interval)
 {
-	if(left->rank < 1)
+	if(GetRank(left) < 1)
 		throwerror(nil, ERank);
-	if(right->rank < left->rank-1)
+	if(GetRank(right) < GetRank(left)-1)
 		throwerror(nil, ERank);
 
 	int i, j;
-	for(i = 0; i < left->rank-1; i++)
-		if(left->shape[left->rank-1-i] != right->shape[right->rank-1-i])
+	for(i = 0; i < GetRank(left)-1; i++)
+		if(left->shape[GetRank(left)-1-i] != right->shape[GetRank(right)-1-i])
 			throwerror(nil, EShape);
 
-	int rank = right->rank + 1 - left->rank;
+	int rank = GetRank(right) + 1 - GetRank(left);
 	int size = 1;
 	int io = globalIO();
 	int n = left->shape[0];
@@ -1920,11 +1920,11 @@ indexOfHelper(Array *left, Array *right, int interval)
 	for(i = 0; i < rank; i++)
 		result->shape[i] = right->shape[i];
 	/* Reshape Y to allow easy picking of sub-arrays */
-	Array *rightshape = allocarray(AtypeInt, 1, right->rank - rank + 1);
-	rightshape->shape[0] = rightshape->size;
+	Array *rightshape = allocarray(AtypeInt, 1, GetRank(right) - rank + 1);
+	rightshape->shape[0] = GetSize(rightshape);
 	rightshape->intdata[0] = size;
-	for(i = 0; i < rightshape->size - 1; i++)
-		rightshape->intdata[rightshape->size-1-i] = right->shape[right->rank-1-i];
+	for(i = 0; i < GetSize(rightshape) - 1; i++)
+		rightshape->intdata[GetSize(rightshape)-1-i] = right->shape[GetRank(right)-1-i];
 	right = fnReshape(rightshape, right);
 
 	Array **lefts = emalloc(sizeof(Array *) * n);