Briot-Ruffini Calc

//----------Functions.h ---------//

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include "global.h"

/* Screen.c */
void erase_down_ln(void);
void clear_screen(void);
void set_color(signed char, signed char);
void upln (__line);
void downln (__line);
void leftln (__line);
void rightln (__line);

/* Functions.c */
void welcome_screen (short);
int is_power(char *);
int power_high(char *, short);
void coeff_put(char *);
void power_less(char *);
int exists_zero(char *);
int ind_briot_ruffini(char *, int *, int, signed char, signed char);
void print_eqs(short *, signed char, signed char*);
int organize_array(char *);
int *search_coefficient(char *, signed char *);
int invert(char *, char *);
void start_calc(char *, short, short *, char *);

//----------Functions.c ---------//

#include "functions.h"

/* Start Screen Effect */
void welcome_screen(short sleep_amount)
{
       register i,j;

       unsigned char screen[7][21]= {
             { X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X },
             { Y, O, B, B, B, O, B, O, B, O, B, O, B, O, O, O, B, O, O, O, Y },
             { Y, O, B, B, B, O, B, O, O, O, B, O, B, B, O, B, B, O, B, B, Y },
             { Y, O, B, B, B, O, B, O, B, O, B, O, B, B, O, B, B, O, O, O, Y },
             { Y, O, B, B, B, O, B, O, B, O, B, O, B, B, O, B, B, O, B, B, Y },
             { Y, O, O, O, B, O, B, O, B, O, B, O, B, B, O, B, B, O, O, O, Y },
             { X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X, X } };


        for(i = 0; i < 7; i++) {
        rightln (20);
        for(j = 0; j < 21; j++) {
                if((i > 0 && i < 6) && (j > 0 && j < 20))
                set_color(1,37);
                else
                set_color(1,34);
                printf(" %c ", screen[i][j]);
        }
        sleep(sleep_amount);
        putchar('\n');
        }
        set_color(1,37);
}

/* Essa função verifica se ainda existe
 * exponeciação na equação */
int is_power(char *args)
{
        register i;

        for(i = 0; args[i]; i++)
        if(args[i] == '^')
                return 1;

        return 0;
}

/* Essa função busca o maior valor
 * da exponeciação na equação */
int power_high(char *args, short option)
{
        register i;
        short number, pos;

        number = pos = 0;
        for(i = 0; args[i]; i++) {
        if(args[i] == '^') {
                if( (atoi(&args[i+1])) > number) {
                number = atoi(&args[i+1]);
                pos = i + 1;
                }
        }
        }

    if(option)
            return pos;
    else
        return number;
}

/* Ordena os coeficientes */
void coeff_put(char *args)
{
        register i;
        signed char count, buffer, numbers[2], pos[8];
        short calc;

        for(i = count =  buffer = 0; args[i]; i++)
        if(args[i] == '^') {
                numbers[count++] = atoi(&args[i+1]);
                pos[buffer++] = i;

        }

        if((numbers[0]-1) != numbers[1]) {
        calc = (numbers[0] - numbers[1] - 1) * 5;

        for(i = calc; i > 0; i--)
                args[strlen(args)] = '0';

        for(i = (strlen(args)-calc-1); i >= (pos[0]+2); i--)
                args[i+calc] = args[i];

        //for(i = 0; i < calc; i++)
                //args[i + pos[0]+2] = '0';

        count = 0;
        for(i = numbers[0]-1; i > numbers[1]; i--) {
                args[(count++) + pos[0]+2] = '+';
                args[(count++) + pos[0]+2] = '0';
                args[(count++) + pos[0]+2] = 'x';
                args[(count++) + pos[0]+2] = '^';
                sprintf(&buffer, "%d", i);
                args[(count++) + pos[0]+2] = buffer;
        }
        }
        if (args[strlen(args)-1] == '0')
        args[strlen(args)-1] = 0;

        //printf("POS: %c %d\n", args[pos[0]+1], pos[0]);
        //printf("X Numbers: %d %d\n\n", numbers[0], numbers[1]);
}

/* Essa função busca o menor valor
 * da exponeciação na equação e preenche
 * o restante dos coeficientes */
void power_less(char *args)
{
        /* Corrigir para colocar coeficientes entre ^4 e ^2 por ex. */
        signed char count;
        short number;
        char *str = malloc(2 * sizeof(char));

        if(str == NULL) {
        puts("Memory cannot be allocated!");
        exit(EXIT_FAILURE);
        }

        number = atoi(&args[strlen(args)-1]);

        for(count = number-1; count > 0; count--) {
        strcat(args, "+0x^");
        sprintf(str, "%d", count);
        strcat(args, str);
        }
        //printf("Num: %d | Str: %s\n", number, args);

        coeff_put(args);

        free(str);
}

/* Esta função verifica se ainda existe algo
 * a ser ordenado */
int exists_zero(char *args)
{
        signed char check;

        check = 0;
        while(*args) {
        if(*args != '0')
                check = 1;
        args++;
        }

        return check;
}

/* Calculo do limite através do Briof-Ruffini */
int ind_briot_ruffini(char *args, int *coeff, int argc, signed char ind, signed char raiz)
{
        register i, j;
        signed char pos = 2+argc, power;
        int result = 0;
        short map [3][pos];
        char str[16];

    power = power_high(args, 0);

        for(i = 0; i < 3; i++)
        for(j = 0; j < (pos); j++)
                map[i][j] = BL;

        map[1][0] = raiz;
        map[1][pos-1] = ind;

        j = 0;
        for(i = 1; i <= argc; i++)
        map[1][i] = coeff[j++];

        for(i = 1; i <= argc; i++) {
        if(i == 1)
                map[2][i] = map[1][i];
        else
                map[2][i] = map[1][i] + map[0][i];
        map[0][i+1] = map[2][i] * map[1][0];
        }
        map[2][pos-1] = map[1][pos-1] + map[0][pos-1];

        j = 1;
        for(i = pos-2; i > 0; i--)
        result += map[2][j++] * pow(raiz, i-1);

        result += map[2][pos-1];

        set_color(1,34);
        for(i = 0; i < 3; i++) {
        for(j = 0; j < (pos); j++) {
                if(map[i][j] == 48)
                printf("\t\t   ");
                else
                printf("\t\t| %d |", map[i][j]);
                // sleep(1);
        }
        //sleep(1);
        putchar('\n');
        }
        set_color(1,37);

    print_eqs(map[2], power-1, &pos);

        return result;
}

void print_eqs(short *numbers, signed char power_n, signed char *pos_n)
{
    register i;
    char *str;
    char buffer[8];

    str = malloc((256 * power_n) * sizeof(char));
    if(str == NULL) {
        puts("Memory cannot be allocated!");
        exit(EXIT_FAILURE);
    }

    for(i = 0; i < (*pos_n)-1; i++) {
            if(numbers[i] == 48);
            else {
            if (power_n >= 1) {
                if(numbers[i] >= 0)
                    sprintf(buffer, "+%dx^%d", numbers[i], (power_n--));
                else
                    sprintf(buffer, "%dx^%d", numbers[i], (power_n--));
            } else
                sprintf(buffer, "+(%d)", numbers[i]);

            strcat(str, buffer);
        }
            // sleep(1);
    }
    printf("\n\t\tNovo polinômio após a aplicação: %s\n", str);

    free(str);
}

/* Responsável por organizar a equação e
 * capturar o termo independente */
int organize_array(char *args)
{
        register i;
        short number;
        signed char pos, count = 0;

        if(*args != '+' && *args != '-') {
        for(i = strlen(args)-1; i >= 0; i--)
                args[i+1] = args[i];

        args[0] = '+';
        }

        for(i = 1; args[i]; i++)
        if(args[i] >= '0' && args[i] <= '9') {
                pos = i;
                count = 1;
                if(args[i+1] >= '0' && args[i+1] <= '9') {
                pos = i+1;
                count = 2;
            if(args[i-1] == '+') {
                    number = atoi(&args[i]);
                    number = atoi(&args[i-1]);
            } else if(args[i-1] == '-') {
                    number = -1 * atoi(&args[i]);
                    number = atoi(&args[i-1]);
            }

            if(args[pos+1] == '\0') {
                    args[i-1] = 0;
                    args[i] = 0;
                    goto finish;

            } else if((args[i-1] == '+' || args[i-1] == '-') &&
                (args[i+2] == '+' || args[i+2] == '-')) {
                    args[i-1] = '0';
                    args[i] = '0';
                    args[i+1] = '0';
                    goto finish;
            }
            } else {
            if(args[i-1] == '+')
                    number = atoi(&args[i]);
            else if(args[i-1] == '-')
                    number = -1 * atoi(&args[i]);

            if(args[i+1] == '\0') {
                    args[i-1] = 0;
                    goto finish;

            } else if((args[i-1] == '+' || args[i-1] == '-') &&
                (args[i+1] == '+' || args[i+1] == '-')) {
                    args[i-1] = '0';
                    args[i] = '0';
                    goto finish;
            }
            }
    }
        finish:
        for(i = pos-count; i < strlen(args); i++)
        args[i] = args[i+(count)+1];

        return number;
}

/* Procura os coeficientes e retorna-os */
int *search_coefficient(char *args, signed char *amount)
{
        register i, j = 0;
        int *numbers;

        numbers = malloc(sizeof(int));
        if(numbers == NULL) {
        puts("Memory cannot be allocated!");
        exit(EXIT_FAILURE);
        }

        for(i = 0; args[i]; i++) {
        numbers = realloc(numbers, i+1);
        if(numbers == NULL) {
                puts("Memory cannot be allocated!");
                exit(EXIT_FAILURE);
        }

        if(args[i] == 'x') {
                if(args[i-2] >= '0' && args[i-2] <= '9')
                numbers[j] = atoi(&args[i-2]);
                else
                numbers[j] = atoi(&args[i-1]);

                if(args[i-2] == '-' || args[i-3] == '-')
                numbers[j] *= -1;
                    j++;
        }
        }
        *amount = j;
        return numbers;
}


/* Função raiz responsável por toda ordenação
 * da equação */
int invert(char *args, char *new_args)
{
        register i, j;
        char *string;
        signed char pos;
        int array = 0;

        string = malloc(strlen(args) * sizeof(char));
        if(string == NULL) {
        puts("Memory cannot be allocated!");
        exit(EXIT_FAILURE);
        }

        if(is_power(args)) {
        pos = power_high(args,1);
        for(i = pos; i >= 0; i--) {
                if(args[i] == '+' || args[i] == '-') {
                for(j = i; j <= pos; j++) {
                        string[array++] = args[j];
                        args[j] = '0';
                }
                goto concatenate;
                }
        }
        } else {
    for(i = strlen(args)-1; i >= 0; i--) {
            if(args[i] == '+' || args[i] == '-')
            for(j = i; j <= strlen(args)-1; j++) {
                    string[array++] = args[j];
                    args[j] = '0';
            }
        }
        goto concatenate;
        }

        concatenate:
        strcat(new_args, string);
        free(string);
}

void start_calc(char *str, const short raiz, short *result_equation, char *name)
{
        char *new_str;
        signed char ind_term, coeff_amount;
        int *coefficient;
        register i;

        printf("\n\t\t--------------------------------\n");
        printf("\t\tPolinômio a ser calculado (%s): %s\n", name, str);

        ind_term = organize_array(str);

        new_str = malloc(strlen(str)+1 * sizeof(char));
        if(new_str == NULL) {
        puts("Memory cannot be allocated!");
        exit(EXIT_FAILURE);
        }

        while(exists_zero(str))
               invert(str, new_str);

        strcpy(str, new_str);
    power_less(str);

    /*for(i = 0; str[i]; i++)
      if(str[i] == '^')
        if(str[i+1] == '1')
          str[i+2] = 0;*/

        coefficient = search_coefficient(str, &coeff_amount);

        printf("\t\tAplicação Briot-Ruffini: %s | Termo Independente: %d | Raiz: %d\n", str, ind_term, raiz);

    printf("\t\tCoeficientes:\t");
        for(i = 0; i < coeff_amount; i++)
        printf(" | %d | ", coefficient[i]);

        putchar('\n');putchar('\n');
        *result_equation = ind_briot_ruffini(str, coefficient, coeff_amount, ind_term, raiz);

        free(coefficient);
        free(new_str);
}