Brihodakar Large Number System

/**
    Brihodakar(Gigantic) Large Number System: Implementation for 100-digit numbers. (designed to be easily extendable)
    Made by Ahnaf Abdullah, 2020

**/

#include <stdio.h>
#include <conio.h>

//char brihodakar1[105] = "", brihodakar2[105] = "", brihodakar3[105] = ""; // char here only serves for smaller footprint, made global to streamline through use of functions
//int i; // Global loop control var
// WHY ARE WE DEPRECATING SO MANY TINGS!?

const int max_num_size = 100;  // DEFINES THE WORKING AREA OF THE BRIHODAKAR ARRAY: change this for dynamically large arrays, make sure to change declarations on BrihodakarX[] accordingly, always make Brihodakar array size slightly larger than this value

void display_num(char brihodakar[]);                                            //  BLNS: Displays the Brihodakar array in human-readable format
void input_to_array(char brihodakar[], int numsize);                            //  BLNS: Regulated input segment (numsize allows for custom input size)
void array_management(char brihodakar[], int option);                           //  BLNS: Multi-purpose array management function
                                                                                /*          Option 1: Input/Unorganized data -> Standard Brihodakar array
                                                                                            Option 2: Standard Brihodakar array -> Big-endian converted Brihodakar array for operations
                                                                                */
void add_array(char conv_array1[], char conv_array2[], char answer[]);          //  BLNS: Adds two big-endian converted Brihodakar arrays, brihodakar1 and brihodakar2
void subtract_array(char conv_array1[], char conv_array2[], char answer[]);     //  BLNS: Subtracts two big-endian converted Brihodakar arrays, conv_array1 MINUS conv_array2. ORDER MATTERS
void copy_array(char destination[], const char source[]);                       //  BLNS: Copies the source array into the destination array


int main(void)
{
    char brihodakar1[max_num_size+5] = "";          // The stars of the show: these arrays hold ordered data representing numbers,
    char brihodakar2[max_num_size+5] = "";          // according to the Brihodakar Large Number System specifications, which is
    char brihodakarans[max_num_size+5] = "";        // actually quite simple.

                                                    /* General form for declaring an abstract Brihodakar array
                                                            char <name>[max_num_size+5] = "";    */

    printf("Testing the implementation of the Brihodakar Large Number System(BLNS). ");

    // BLNS: regulated input segment
    printf("\nPlease enter the first number: \n");
    input_to_array(brihodakar1, max_num_size);
    printf("\nPlease enter the second number: \n");
    input_to_array(brihodakar2, max_num_size);

    printf("\n\n\nDEBUG: Displaying array\n");
    display_num(brihodakar1); // DEBUG
    printf("\n");
    display_num(brihodakar2); // DEBUG

    array_management(brihodakar1, 1);
    array_management(brihodakar2, 1);
        // brihodakarans is a non-input array and hence it has no terminating character. This must be added
        brihodakarans[0] = 'A';
        array_management(brihodakarans, 1);

    printf("\n\n\nDEBUG: Displaying array after basic management\n");
    display_num(brihodakar1);
    printf("\n");
    display_num(brihodakar2);

    // Conversion to Big-Endian for addition
    array_management(brihodakar1, 2);
    array_management(brihodakar2, 2);
    array_management(brihodakarans, 2);

    printf("\n\n\nDEBUG: Displaying array after big-endian conversion\n");
    display_num(brihodakar1);
    printf("\n");
    display_num(brihodakar2);
    printf("\n");
    display_num(brihodakarans);


    // Addition query (DEBUG)
    printf("\n\n\nAdding the two arrays\n");
    add_array(brihodakar1, brihodakar2, brihodakarans);
    printf("DEBUG: Displaying array after addition\n");
    display_num(brihodakarans);
    array_management(brihodakarans, 1);
    printf("\n\n\nAdding the two arrays, result: \n");
    display_num(brihodakarans);

    // Copying test, copy Brihodakarans to Brihodakar 1 and 2
    copy_array(brihodakar1, brihodakarans);
    copy_array(brihodakar2, brihodakarans);

    printf("\n\n\nDEBUG: Copying answer to first and second array, displaying array\n");
    display_num(brihodakar1);
    printf("\n");
    display_num(brihodakar2);
    printf("\n");
    display_num(brihodakarans);

    return 0;
}

void display_num(char brihodakar[])
{
    int m;
    for (m=0; brihodakar[m] != 'A'; m++)
    {
        printf("%d", brihodakar[m]);
    }
}

void input_to_array(char brihodakar[], int numsize)
{
    char in;
    int i;

    input:
        for (i=0; i<numsize; i++)
        {
            in = getche();

            if (in >= '0' && in <= '9')
            {
                brihodakar[i] = in - '0';
                if (i == numsize - 1)
                    brihodakar[i+1] = 'A';
            }
            else
            {
                if (in == '\r')
                {
                    brihodakar[i] = 'A'; // Terminating character, use this to test
                    break;
                }
                if (in == '.')
                {
                    printf("\nSorry, Brihodakar is for integers only... Please try again\nPlease enter the number: ");
                    goto input;
                }

                printf("   Illegitimate input, please enter numbers only, try again\nPlease enter the number: ");
                // gotophobes... Explain how you can restart the whole input sequence without goto...
                // Oh yeah, and it has to be intuitive and simple. The goto here isn't blowing up the program, so pls stop whining
                goto input;
            }
        }
}

void array_management(char brihodakar[], int option)
{
    int i;

    switch (option)
    {
    case 1: //  Input --> Standard Brihodakar array
        {
            if (!(brihodakar[0] == 0 && brihodakar[1] == 'A'))            // remove all leading zeroes before number
            {
                while (brihodakar[0] == 0)     // Move every element one space forward IF there is a zero in front of it
                {
                    int k;
                    for (k = 0; k<max_num_size; k++)
                        brihodakar[k] = brihodakar[k+1];
                }          // This operation can cause a large string of zeroes in brihodakar[] to turn into a null array. So, just in case

                if (brihodakar[0] == 'A') // Turns a null array into an array of 0.
                {
                    brihodakar[0] = 0; brihodakar[1] = 'A';
                }
            }
        }
        break;
    case 2: // Standard Brihodakar array --> Big-Endian Brihodakar array for operations
        {
            // WARMING: DO NOT EXECUTE THIS OPERATION ON AN UNORDERED ARRAY (perform array_management(array, 1); first)
            while (brihodakar[max_num_size] != 'A')
            {
                int k;
                for (k = max_num_size; k >= 0; k--)
                {
                    brihodakar[k] = brihodakar[k-1];
                }
            }
        }
        break;
    }

}

void add_array(char conv_array1[], char conv_array2[], char answer[])
{
    // Test big-endianess of arrays
    int i;

    if (conv_array1[max_num_size] != 'A' || conv_array2[max_num_size] != 'A'|| answer[max_num_size] != 'A')
    {
        printf("--DEBUG: Addition failed: Improper array configuration. Please initialize/set arrays properly and try again\n");
        return;
    }
    else
    {
        char tempstore[max_num_size-5] = "";
        copy_array(tempstore, conv_array1); // this allows us to add carries to conv_array1, since the original value of conv_array1 is now stored here.

        for (i=max_num_size-1; i>=0; i--)
        {
            int digitholder;

            digitholder = conv_array1[i] + conv_array2[i];

            if (digitholder > 9)
            {
                digitholder = digitholder - 10;
                answer[i] = digitholder;   // Brihodakar3 is the answer array that holds the computation, it must be initialized to Big-Endian 0 array first.
                if (i > 0)
                    conv_array1[i-1] = conv_array1[i-1] + 1;
                else
                    printf("\nWARNING!!!! OVERFLOW!!! THE ANSWER MAY BE WRONG\n");
            }
            else
            {
                answer[i] = digitholder;
            }
        }

        copy_array(conv_array1, tempstore);
    }
}

void copy_array(char destination[], const char source[])
{
    int i=0;
    while (1)
    {
        destination[i] = source[i];
        if (destination[i] == 'A')
            break;
        i++;
    }
}