eliaskohout/ctensor
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Added comments

Browse Source
This commit is contained in:
Elias Kohout
2023-09-03 09:45:20 +02:00
parent 7d96a0f7f1
commit 427c75f1a6
3 changed files with 193 additions and 71 deletions
Download Patch File Download Diff File Expand all files Collapse all files

228
tensor.c
View File

@@ -2,11 +2,19 @@
tensor tensor_new(void)
{
/* Creates a new tensor struct and returns it.
*
* @return A tensor (pointer to memory for a _tensor struct)
*/
return calloc(1, sizeof(struct _tensor));
}
void tensor_destroy(tensor t)
{
/* Destroys a tensor struct by free its memory.
*
* @param t The tensor that should be deleted
*/
if (!tensor_is_empty(t)) {
free(t->size);
free(t->elements);
@@ -17,11 +25,24 @@ void tensor_destroy(tensor t)
bool tensor_is_empty(const tensor t)
{
/* Checks whether a tensor is empty.
*
* @param t The tensor to check
*
* @return true when the tensor is empty, false otherwise
*/
return t->elements == NULL || t->size == NULL;
}
bool tensor_is_equal(const tensor t1, const tensor t2)
{
/* Checks whether two tensor are equal.
*
* @param t1 The first tensor
* @param t2 The seconds tensor
*
* @return true when the two tensors are equal, false otherwise
*/
assert(!tensor_is_empty(t1));
assert(!tensor_is_empty(t2));
@@ -36,19 +57,34 @@ bool tensor_is_equal(const tensor t1, const tensor t2)
return true;
}
uint8_t _tensor_check_size(const uint32_t *size, uint8_t rank)
bool _tensor_check_size(const uint32_t *size, uint8_t rank)
{
/* Checks whether a size array is valid.
*
* @param size A size array
* @param rank The length of the size array
*
* @return true when the size is valid, false otherwise
*/
uint8_t i;
if(rank < 0) return 0;
if(rank < 0) return false;
for(i = 0; i < rank; i++) {
if(size[i] < 1) return 0;
if(size[i] < 1) return false;
}
return 1;
return true;
}
uint8_t _tensor_set_size(tensor t, const uint32_t *size, uint8_t rank)
bool _tensor_set_size(tensor t, const uint32_t *size, uint8_t rank)
{
/* Sets the size of a Tensor. During this process all data in the tensor t is lost. */
/* Sets the size of a Tensor. During this process all data in the tensor t
* is lost.
*
* @param t The tensor that should be changed
* @param size The final size of the tensor t
* @param rank The length of size
*
* @return true if the process was successful, false when an error occured
*/
uint32_t *temp_size;
uint32_t *temp_index_offset;
@@ -56,7 +92,7 @@ uint8_t _tensor_set_size(tensor t, const uint32_t *size, uint8_t rank)
uint8_t i, j;
uint32_t num_elem = 1;
if(!_tensor_check_size(size, rank)) return 0;
if(!_tensor_check_size(size, rank)) return false;
/* Try allocating memory for the size/ index_offset array of the tensor */
for(i = 0; i < rank; i++) {
@@ -68,7 +104,7 @@ uint8_t _tensor_set_size(tensor t, const uint32_t *size, uint8_t rank)
if((temp_size == NULL && rank != 0) || (temp_index_offset == NULL && rank != 0) || temp_elements == NULL) {
free(temp_size);
free(temp_index_offset);
return 0;
return false;
}
/* Freeing old memory. */
@@ -92,11 +128,20 @@ uint8_t _tensor_set_size(tensor t, const uint32_t *size, uint8_t rank)
t->elements = temp_elements;
t->num_elem = num_elem;
return 1;
return true;
}
uint8_t tensor_set(tensor t, const uint32_t *index, dtype val)
bool tensor_set(tensor t, const uint32_t *index, dtype val)
{
/* Set the value at a index of a tensor.
*
* @param t The tensor to change
* @param index The index of the value that should change, the length of
* this array is defined by the rank of t
* @param val The updated value
*
* @return true if the change was successful, false otherwise
*/
assert(!tensor_is_empty(t));
uint8_t i;
@@ -104,20 +149,30 @@ uint8_t tensor_set(tensor t, const uint32_t *index, dtype val)
if(t->rank == 0) {
t->elements[0] = val;
return 1;
return true;
}
for(i = 0; i < t->rank; i++) {
if(t->size[i] <= index[i]) return 0;
if(t->size[i] <= index[i]) return false;
offset += t->index_offsets[i] * index[i];
}
t->elements[offset] = val;
return 1;
return true;
}
dtype tensor_get(const tensor t, const uint32_t *index, uint8_t *success)
dtype tensor_get(const tensor t, const uint32_t *index, bool *success)
{
/* Gets a value at a index from a tensor.
*
* @param t The tensor from which to get the value from
* @param index The index of the value to get, the length of this array is
* defined by the rank of t
* @param success Is set according to the exit status of the function, if it
* is NULL it is ignored
*
* @return The retrieved value, DTYPE_NULL in case of an error
*/
assert(!tensor_is_empty(t));
uint8_t i;
@@ -127,98 +182,156 @@ dtype tensor_get(const tensor t, const uint32_t *index, uint8_t *success)
for(i = 0; i < t->rank; i++) {
if(t->size[i] <= index[i]) {
if(success != NULL) *success = 0;
return 0;
if(success != NULL) *success = false;
return DTYPE_ZERO;
}
offset += t->index_offsets[i] * index[i];
}
if(success != NULL) *success = 1;
if(success != NULL) *success = true;
return t->elements[offset];
}
uint8_t tensor_init_one(tensor t, uint8_t rank, const uint32_t *size)
bool tensor_init_one(tensor t, const uint32_t *size, uint8_t rank)
{
/* Inits (sets the size) and filles a tensor with ones.
*
* @param t The tensor to fill
* @param size The final size of the tensor t
* @param rank The length of size array
*
* @return true when successful, false otherwise
*/
uint32_t i;
if(!_tensor_set_size(t, size, rank)) return 0;
if(!_tensor_set_size(t, size, rank)) return false;
for(i = 0; i < t->num_elem; i++) {
t->elements[i] = DTYPE_ONE;
}
return 1;
return true;
}
uint8_t tensor_init_zero(tensor t, uint8_t rank, const uint32_t *size)
bool tensor_init_zero(tensor t, const uint32_t *size, uint8_t rank)
{
/* Inits (sets the size) and filles a tensor with zeros.
*
* @param t The tensor to fill
* @param size The final size of the tensor t
* @param rank The length of size array
*
* @return true when successful, false otherwise
*/
uint32_t i;
if(!_tensor_set_size(t, size, rank)) return 0;
if(!_tensor_set_size(t, size, rank)) return false;
for(i = 0; i < t->num_elem; i++) {
t->elements[i] = DTYPE_ZERO;
}
return 1;
return true;
}
uint8_t tensor_init_rand(tensor t, uint8_t rank, const uint32_t *size, dtype max)
bool tensor_init_rand(tensor t, const uint32_t *size, uint8_t rank, dtype max)
{
/* Inits (sets the size) and filles a tensor with random values below or
* equal to the max value.
*
* @param t The tensor to fill
* @param size The final size of the tensor t
* @param rank The length of size array
* @param max The maximal value filled in
*
* @return true when successful, false otherwise
*/
uint32_t i;
static long last_seed;
last_seed += time(NULL) * 200 + rand();
srand(last_seed);
if(!_tensor_set_size(t, size, rank)) return 0;
if(!_tensor_set_size(t, size, rank)) return false;
for(i = 0; i < t->num_elem; i++) {
t->elements[i] = DTYPE_RAND(max);
}
return 1;
return true;
}
uint8_t tensor_cpy(tensor t1, const tensor t2)
bool tensor_cpy(tensor t1, const tensor t2)
{
/* Copies the contents of t2 into t1.
*
* @param t1 The tensor in which to copy the values
* @param t2 The tensor from which to copy the values
*
* @return true when successful, false otherwise
*/
assert(!tensor_is_empty(t2));
uint32_t i;
if(!_tensor_set_size(t1, t2->size, t2->rank)) return 0;
if(!_tensor_set_size(t1, t2->size, t2->rank)) return false;
for(i = 0; i < t2->num_elem; i++) {
t1->elements[i] = t2->elements[i];
}
return 1;
return true;
}
uint8_t tensor_add_inplace(tensor t1, const tensor t2)
bool tensor_add_inplace(tensor t1, const tensor t2)
{
/* Adds the values of t2 onto the values of t1. t1 and t2 need to have the
* same size.
*
* @param t1 The tensor on which the values of t2 are added
* @param t2 The tensor whose values are added
*
* @return true when successful, false otherwise
*/
assert(!tensor_is_empty(t1));
assert(!tensor_is_empty(t2));
uint32_t i;
if(t1->rank != t2->rank) return 0;
if(t1->rank != t2->rank) return false;
for(i = 0; i < t1->rank; i++) {
if(t1->size[i] != t2->size[i]) return 0;
if(t1->size[i] != t2->size[i]) return false;
}
for(i = 0; i < t1->num_elem; i++) {
t1->elements[i] = DTYPE_ADD(t1->elements[i], t2->elements[i]);
}
return 1;
return true;
}
uint8_t tensor_sub_inplace(tensor t1, const tensor t2)
bool tensor_sub_inplace(tensor t1, const tensor t2)
{
/* Subtracts the values of t2 from the values of t1. t1 and t2 need to have
* the same size.
*
* @param t1 The tensor from which the values of t2 are subtracted
* @param t2 The tensor whose values are subtracted
*
* @return true when successful, false otherwise
*/
assert(!tensor_is_empty(t1));
assert(!tensor_is_empty(t2));
uint32_t i;
if(t1->rank != t2->rank) return 0;
if(t1->rank != t2->rank) return false;
for(i = 0; i < t1->rank; i++) {
if(t1->size[i] != t2->size[i]) return 0;
if(t1->size[i] != t2->size[i]) return false;
}
for(i = 0; i < t1->num_elem; i++) {
t1->elements[i] = DTYPE_SUB(t1->elements[i], t2->elements[i]);
}
return 1;
return true;
}
tensor tensor_add(const tensor t1, const tensor t2)
{
/* Adds to tensors returning the result as a tensor.
*
* @param t1 The first tensor to add
* @param t2 The second tensor to add
*
* @return The result of the operation, NULL if an error occurs
*/
assert(!tensor_is_empty(t1));
assert(!tensor_is_empty(t2));
@@ -231,6 +344,13 @@ tensor tensor_add(const tensor t1, const tensor t2)
tensor tensor_sub(const tensor t1, const tensor t2)
{
/* Subtracts to tensors returning the result as a tensor.
*
* @param t1 The tensor to subtract from
* @param t2 The tensor that is subtracted
*
* @return The result of the operation, NULL if an error occurs
*/
assert(!tensor_is_empty(t1));
assert(!tensor_is_empty(t2));
@@ -244,8 +364,12 @@ tensor tensor_sub(const tensor t1, const tensor t2)
void tensor_print(const tensor t)
{
/* Prints a tensor to stdout.
*
* @param t The tensor to print
*/
uint32_t i, j;
uint32_t *indx;
uint32_t *index;
if(tensor_is_empty(t)){
printf("<empty tensor>\n");
@@ -285,41 +409,41 @@ void tensor_print(const tensor t)
}
} else if (t->rank == 2) {
/* matix */
indx = malloc(sizeof(int) * 2);
index = malloc(sizeof(int) * 2);
if(t->size[0] == 1) {
putchar('(');
indx[0] = 0;
index[0] = 0;
for(i = 0; i < t->size[1]; i++) {
indx[1] = i;
DTYPE_PRINT(tensor_get(t, indx, NULL));
index[1] = i;
DTYPE_PRINT(tensor_get(t, index, NULL));
}
printf(")\n");
} else {
printf("\n/");
indx[0] = 0;
index[0] = 0;
for(i = 0; i < t->size[1]; i++) {
indx[1] = i;
DTYPE_PRINT(tensor_get(t, indx, NULL));
index[1] = i;
DTYPE_PRINT(tensor_get(t, index, NULL));
}
printf("\\\n");
for(i = 1; i < t->size[0] - 1; i++) {
putchar('|');
indx[0] = i;
index[0] = i;
for(j = 0; j < t->size[1]; j++) {
indx[1] = j;
DTYPE_PRINT(tensor_get(t, indx, NULL));
index[1] = j;
DTYPE_PRINT(tensor_get(t, index, NULL));
}
printf("|\n");
}
printf("\\");
indx[0] = t->size[0] - 1;
index[0] = t->size[0] - 1;
for(i = 0; i < t->size[1]; i++) {
indx[1] = i;
DTYPE_PRINT(tensor_get(t, indx, NULL));
index[1] = i;
DTYPE_PRINT(tensor_get(t, index, NULL));
}
printf("/\n");
}
free(indx);
free(index);
} else {
putchar('[');
for(i = 0; i < t->num_elem; i++) {