Matrix Calculator Assignment in C Language
In this sample assignment solution in C, students are required to create a calculator for performing Matrix Operations. The calculator should exploit the expected sparseness of its matrix operands. The result has to be produced in the form of a C program which is capable of performing fast matrix operations even for large matrices. The only condition is that the matrix should have required sparseness.
SOLUTION : –
#include
#include
#include “List.h”
// struct is same as public class Node in java
typedef struct NodeObj
{
type data;
struct NodeObj* prev;
struct NodeObj* next;
}NodeObj;
typedef NodeObj* Node; // private Node type
// struct is same as public class List in java
typedef struct ListObj
{
Node front;
Node back;
Node cursor;
int index;
int length;
}ListObj;
// newNode()
// same as Node class constructor
Node newNode(type data)
{
Node N = NULL;
N = malloc(sizeof(NodeObj));
//printf(“List.c: newNode(): N malloc address: %p\n”, N);
N->data = data;
N->prev = NULL;
N->next = NULL;
return (N);
}
// freeNode()
// frees heap memory pointed to by *pN, sets *pN to NULL
void freeNode(Node* pN)
{
//printf(“List.c: freeNode(): pN is: %p\n”, pN);
//printf(“List.c: freeNode(): *pN is: %p\n”, *pN);
if (pN != NULL && *pN != NULL)
{
//printf(“!!List.c: freeNode(): free(*pN) called\n”);
free(*pN);
*pN = NULL;
}
}
// newList()
// equivalent to List class constructor
List newList(void)
{
List L = NULL;
L = malloc(sizeof(ListObj));
//printf(“List.c: newList(): L malloc address: %p\n”, L);
L->front = NULL;
L->back = NULL;
L->cursor = NULL;
L->index = -1;
L->length = 0;
return (L);
}
// freeList()
// frees all heap memory associated with List *pL
// and sets *pL to NULL
void freeList(List* pL)
{
//printf(“List.c: freeList() called\n”);
if (pL != NULL && *pL!= NULL)
{
while (length(*pL) > 0)
{
//printf(“List.c: freeList(): deleteFront() called\n”);
deleteFront(*pL);
}
//printf(“!!List.c: freeList(): free(*pL) called for List\n”);
free(*pL);
*pL = NULL;
}
}
// Access functions —————————————
// length()
// returns the number of elements in this List
int length(List L)
{
if (L == NULL)
{
printf(“List Error: calling length() on NULL List reference\n”);
exit(1);
}
return L->length;
}
// index()
// returns the index of the cursor of the list
int index(List L)
{
//printf(“List.c: index() is called.\n”);
if (L == NULL)
{
printf(“List Error: calling index() on NULL List reference\n”);
exit(1);
}
if (length(L) <= 0)
{
//printf(“List.c: index() called: got to if statement.\n”);
return -1;
}
//printf(“List.c: index(): index is: %d\n”, L->index);
return L->index;
}
// front()
// returns the front element. pre: length() > 0
type front(List L)
{
if (L == NULL)
{
printf(“List Error: calling front() on NULL List reference\n”);
exit(1);
}
if (length(L) <= 0)
{
printf(“List Error: front() called on empty List\n”);
}
return L->front->data;
}
// back()
// returns the back element. pre: length() > 0
type back(List L)
{
if (L == NULL)
{
printf(“List Error: calling back() on NULL List reference\n”);
exit(1);
}
if (length(L) <= 0)
{
printf(“List Error: back() called on empty List\n”);
}
return L->back->data;
}
// get()
// returns the cursor element. pre: length() > 0 and index() > 0
type get(List L)
{
if (L == NULL)
{
printf(“List Error: calling get() on NULL List reference\n”);
exit(1);
}
if (length(L) <= 0)
{
printf(“List Error: get() called on empty List\n”);
}
if (L->cursor == NULL)
{
printf(“List Error: cannot get() if cursor is NULL\n”);
}
return L->cursor->data;
}
// Manipulation procedures ————————————————
// clear()
// resets this List to its original empty state
void clear(List L)
{
if (L == NULL)
{
printf(“List Error: calling clear() on a NULL List reference\n”);
exit(1);
}
while (length(L) > 0)
{
//printf(“List.c: freeList(): deleteFront() called\n”);
deleteFront(L);
}
L->front = NULL;
L->back = NULL;
L->cursor = NULL;
L->index = -1;
L->length = 0;
}
// moveFront()
// places the cursor to the front of the List
void moveFront(List L)
{
if (L == NULL)
{
printf(“List Error: calling moveFront() on a NULL List reference\n”);
exit(1);
}
if (length(L) > 0)
{
L->cursor = L->front;
L->index = 0;
}
}
// moveBack()
// places the cursor at the back of the List
void moveBack(List L)
{
if (L == NULL)
{
printf(“List Error: calling moveBack() on a NULL List reference\n”);
exit(1);
}
if (length(L) > 0)
{
L->cursor = L->back;
L->index = L->length – 1;
}
}
// movePrev()
// moves cursor one step toward the front of the List
void movePrev(List L)
{
if (L == NULL)
{
printf(“List Error: calling movePrev() on a NULL List reference\n”);
exit(1);
}
if (L->cursor == L->front)
{
L->cursor = NULL;
L->index = -1;
}
else
{
L->cursor = L->cursor->prev;
L->index–;
}
}
// moveNext()
// moves the cursor one step toward the back of the List
void moveNext(List L)
{
if (L == NULL)
{
printf(“List Error: calling moveNext() on a NULL List reference\n”);
exit(1);
}
if (L->cursor == L->back)
{
L->cursor = NULL;
L->index = -1;
}
else
{
L->cursor = L->cursor->next;
L->index++;
}
}
// prepend()
// inserts a new element into the front of the List
void prepend(List L, type data)
{
if (L == NULL)
{
printf(“List Error: calling prepend() on a NULL List reference\n”);
exit(1);
}
Node N = newNode(data);
if (L->front == NULL)
{
L->front = N;
L->back = N;
L->cursor = L->front;
}
else
{
L->front->prev = N;
N->next = L->front;
L->front = N;
L->index++;
}
L->length++;
}
// append()
// inserts a new element into the back of the List
void append(List L, type data)
{
if (L == NULL)
{
printf(“List Error: calling apend() on a NULL List reference\n”);
exit(1);
}
Node N = newNode(data);
if (L->back == NULL)
{
L->front = N;
L->back = N;
L->cursor = L->back;
}
else
{
L->back->next = N;
N->prev = L->back;
L->back = N;
N->next = NULL;
}
L->length++;
}
// insertBefore()
// inserts new element before cursor
void insertBefore(List L, type data)
{
if (L == NULL)
{
printf(“List Error: calling apend() on a NULL List reference\n”);
exit(1);
}
if (L->cursor == NULL)
{
printf(“List Error: cannot insertBefore() if cursor is undefined\n”);
}
if (L->cursor == L->front)
{
prepend(L, data);
}
else
{
Node N = newNode(data);
N->prev = L->cursor->prev;
N->next = L->cursor;
L->cursor->prev->next = N;
L->cursor->prev = N;
L->index++;
L->length++;
}
}
// insertAfter()
// inserts new element after cursor
void insertAfter(List L, type data)
{
if (L == NULL)
{
printf(“List Error: calling apend() on a NULL List reference\n”);
exit(1);
}
if (length(L) <= 0)
{
printf(“List Error: insertAfter() called on empty List\n”);
}
if (L->cursor == L->back)
{
append(L, data);
}
else
{
Node N = newNode(data);
L->cursor->next->prev = N;
N->next = L->cursor->next;
N->prev = L->cursor;
L->cursor->next = N;
L->length++;
}
}
// deleteFront()
// deletes front element
void deleteFront(List L)
{
//printf(“List.c: deleteFront() called\n”);
if (L == NULL)
{
printf(“List Error: calling apend() on a NULL List reference\n”);
exit(1);
}
if (length(L) <= 0)
{
printf(“List Error: cannot deleteFront() empty List\n”);
}
else
{
//printf(“List.c: freeList(): node is: %d\n”, L->front->data);
//printf(“—————————————\n”);
//printf(“List.c: deleteFront(): L.length is: %d\n”, L->length);
//printf(“List.c: deleteFront(): L->front is: %p\n”, L->front);
//printf(“List.c: deleteFront(): L->cursor is: %p\n”, L->cursor);
if (L->length == 1)
{
Node N = L->front;
//printf(“List.c: case 1: deleteFront(): N is: %p\n”, N);
freeNode(&N);
//printf(“List.c: case 1: deleteFront(): front.data is: %d\n”, L->front->data);
L->cursor = NULL;
L->front = L->back = NULL;
L->index = -1;
}
else //if (L->length > 1)
{
Node N = L->front;
//printf(“List.c: case 2: deleteFront(): front.data is: %d\n”, L->front->data);
L->front = L->front->next;
L->front->prev = NULL;
if (L->cursor != NULL)
{
L->index–;
}
freeNode(&N);
}
L->length–;
}
}
// deleteBack()
// deletes back element
void deleteBack(List L)
{
if (L == NULL)
{
printf(“List Error: cannot deleteBack() on NULL List reference\n”);
}
if (length(L) <= 0)
{
printf(“List Error: cannot deleteBack() empty List\n”);
}
else
{
if (L->length == 1)
{
Node N = L->back;
freeNode(&N);
L->cursor = NULL;
L->front = L->back = NULL;
L->index = -1;
}
else //if (L->length > 1)
{
Node N = L->back;
L->back = L->back->prev;
L->back->next = NULL;
if (L->index == L->length – 1)
{
L->index = -1;
}
freeNode(&N);
}
L->length–;
//printf(“List.c: deleteBack(): current index is: %d\n”, L->index);
}
}
// delete()
// deletes cursor element
void delete(List L)
{
if (L == NULL)
{
printf(“List Error: cannot deleteBack() on NULL List reference\n”);
}
if (length(L) <= 0)
{
printf(“List Error: cannot delete() empty List”);
}
if (L->cursor == NULL)
{
printf(“List Error: cannot delete() on undefined cursor”);
}
if (L->cursor == L->front)
{
deleteFront(L);
}
else if (L->cursor == L->back)
{
deleteBack(L);
}
else
{
Node N = L->cursor;
L->cursor->prev->next = L->cursor->next;
L->cursor->next->prev = L->cursor->prev;
freeNode(&N);
L->length–;
}
L->index = -1;
}