numerus_utils.c

Go to the documentation of this file.

#include <math.h>     /* For `round()`, `floor()`  */
#include <ctype.h>    /* For `isspace()`    */
#include <stdio.h>    /* For `snprintf()`   */
#include <stdlib.h>   /* For `malloc()`     */
#include <string.h>   /* For `strcasecmp()` */
#include <stdbool.h>  /* To use booleans `true` and `false` */
#include "numerus_internal.h"


short _num_is_zero(char *roman) {
    if (*roman == '-') {
        roman++;
    }
    if (strcasecmp(roman, NUMERUS_ZERO) != 0) {
        return false;
    } else {
        return true;
    };
}


void _num_headtrim_check_numeral_and_errcode(char **roman, int **errcode) {
    if (*errcode == NULL) {
        *errcode = &numerus_error_code;
    }
    if (*roman == NULL) {
        numerus_error_code = NUMERUS_ERROR_NULL_ROMAN;
        **errcode = NUMERUS_ERROR_NULL_ROMAN;
        return;
    }
    while (isspace(**roman)) {
        (*roman)++;
    }
    if (**roman == '\0') {
        numerus_error_code = NUMERUS_ERROR_EMPTY_ROMAN;
        **errcode = NUMERUS_ERROR_EMPTY_ROMAN;
        return;
    }
    numerus_error_code = NUMERUS_OK;
    **errcode = NUMERUS_OK;
}


short numerus_is_zero(char *roman, int *errcode) {
    _num_headtrim_check_numeral_and_errcode(&roman, &errcode);
    if (*errcode != NUMERUS_OK) {
        return false;
    }
    return _num_is_zero(roman);
}


short numerus_is_long_numeral(char *roman, int *errcode) {
    _num_headtrim_check_numeral_and_errcode(&roman, &errcode);
    if (*errcode != NUMERUS_OK) {
        return false;
    }
    short i = 0;
    short underscores_found = 0;
    while (*roman != '\0') {
        if (i > NUMERUS_MAX_LENGTH) {
            numerus_error_code = NUMERUS_ERROR_TOO_LONG_NUMERAL;
            *errcode = NUMERUS_ERROR_TOO_LONG_NUMERAL;
            return false;
        }
        if (*roman == '_') {
            underscores_found++;
        }
        i++;
        roman++;
    }
    if (underscores_found == 2) {
        numerus_error_code = NUMERUS_OK;
        *errcode = NUMERUS_OK;
        return true;
    } else if (underscores_found == 0){
        numerus_error_code = NUMERUS_OK;
        *errcode = NUMERUS_OK;
        return false;
    } else if (underscores_found == 1){
        numerus_error_code = NUMERUS_ERROR_MISSING_SECOND_UNDERSCORE;
        *errcode = NUMERUS_ERROR_MISSING_SECOND_UNDERSCORE;
        return false;
    } else {
        numerus_error_code = NUMERUS_ERROR_UNDERSCORE_AFTER_LONG_PART;
        *errcode = NUMERUS_ERROR_UNDERSCORE_AFTER_LONG_PART;
        return false;
    }
}


short numerus_is_float_numeral(char *roman, int *errcode) {
    _num_headtrim_check_numeral_and_errcode(&roman, &errcode);
    if (*errcode != NUMERUS_OK) {
        return false;
    }
    short i = 0;
    while (*roman != '\0') {
        if (i > NUMERUS_MAX_LENGTH) {
            numerus_error_code = NUMERUS_ERROR_TOO_LONG_NUMERAL;
            *errcode = NUMERUS_ERROR_TOO_LONG_NUMERAL;
            return false;
        }
        if (*roman == 'S' || *roman == 's' || *roman == '.') {
            numerus_error_code = NUMERUS_OK;
            *errcode = NUMERUS_OK;
            return true;
        } else {
            i++;
        }
        roman++;
    }
    numerus_error_code = NUMERUS_OK;
    *errcode = NUMERUS_OK;
    return false;
}


short numerus_sign(char *roman, int *errcode) {
    _num_headtrim_check_numeral_and_errcode(&roman, &errcode);
    if (*errcode != NUMERUS_OK) {
        return 0;
    }
    if (_num_is_zero(roman)) {
        return 0;
    }
    if (*roman == '-') {
        return -1;
    } else {
        return 1;
    }
}


short numerus_count_roman_chars(char *roman, int *errcode) {
    _num_headtrim_check_numeral_and_errcode(&roman, &errcode);
    if (*errcode != NUMERUS_OK) {
        return -1;
    }
    if (_num_is_zero(roman)) {
        numerus_error_code = NUMERUS_OK;
        *errcode = NUMERUS_OK;
        return (short) strlen(NUMERUS_ZERO);
    }
    short i = 0;
    while (*roman != '\0') {
        if (i > NUMERUS_MAX_LENGTH) {
            numerus_error_code = NUMERUS_ERROR_TOO_LONG_NUMERAL;
            *errcode = NUMERUS_ERROR_TOO_LONG_NUMERAL;
            return -2;
        }
        switch (toupper(*roman)) {
            case '_': {
                roman++; // ignore underscores
                break;
            }
            case '-':
            case 'M':
            case 'D':
            case 'C':
            case 'L':
            case 'X':
            case 'V':
            case 'I':
            case 'S':
            case '.': {
                roman++;
                i++; // count every other roman char
                break;
            }
            default: {
                if (isspace(*roman)) {
                    numerus_error_code = NUMERUS_ERROR_WHITESPACE_CHARACTER;
                    *errcode = NUMERUS_ERROR_WHITESPACE_CHARACTER;
                    return -3;
                } else {
                    numerus_error_code = NUMERUS_ERROR_ILLEGAL_CHARACTER;
                    *errcode = NUMERUS_ERROR_ILLEGAL_CHARACTER;
                    return -4;
                }
            }
        }
    }
    numerus_error_code = NUMERUS_OK;
    *errcode = NUMERUS_OK;
    return i;
}


short numerus_compare_value(char *roman_bigger, char *roman_smaller, int *errcode) {
    if (errcode == NULL) {
        errcode = &numerus_error_code;
    }
    short twelfths_bigger;
    long int_part_bigger = numerus_roman_to_int_part_and_twelfths(roman_bigger,
                                                                  &twelfths_bigger,
                                                                  errcode);
    if (*errcode != NUMERUS_OK) {
        numerus_error_code = *errcode;
        return 0;
    }
    short twelfths_smaller;
    long int_part_smaller = numerus_roman_to_int_part_and_twelfths(
            roman_smaller, &twelfths_smaller, errcode);
    if (*errcode != NUMERUS_OK) {
        numerus_error_code = *errcode;
        return 0;
    }
    if (int_part_bigger > int_part_smaller) {
        return 1;
    } else if (int_part_bigger < int_part_smaller) {
        return -1;
    } else {
        /* Equal int parts */
        if (twelfths_bigger > twelfths_smaller) {
            return 1;
        } else if (twelfths_bigger < twelfths_smaller) {
            return -1;
        } else {
            /* Equal twelfths */
            return 0;
        }
    }
}


static size_t _num_overlining_alloc_size(char *roman) {
    size_t alloc_size_to_add = 0;
    char *first_underscore = NULL;
    char *second_underscore = NULL;
    while (second_underscore == NULL && *roman != '\0') {
        if (*roman == '_') {
            if (first_underscore == NULL) {
                first_underscore = roman;
            } else {
                second_underscore = roman;
            }
        } else {
            alloc_size_to_add++;
        }
        roman++;
    }
    /* Includes space for a '\n' */
    alloc_size_to_add += second_underscore - first_underscore;
    return alloc_size_to_add;
}


char *numerus_overline_long_numerals(char *roman, int *errcode) {
    _num_headtrim_check_numeral_and_errcode(&roman, &errcode);
    if (*errcode != NUMERUS_OK) {
        return NULL;
    }
    int length = numerus_count_roman_chars(roman, errcode);
    if (*errcode != NUMERUS_OK) {
        numerus_error_code = *errcode;
        return NULL;
    }
    if (numerus_is_long_numeral(roman, errcode)) {
        char *pretty_roman_start = malloc(length + _num_overlining_alloc_size(roman));
        if (pretty_roman_start == NULL) {
            numerus_error_code = NUMERUS_ERROR_MALLOC_FAIL;
            *errcode = NUMERUS_ERROR_MALLOC_FAIL;
            return NULL;
        }
        char *roman_start = roman;
        char *pretty_roman = pretty_roman_start;

        /* Skip minus sign */
        if (*roman == '-') {
            *(pretty_roman++) = ' ';
            roman++;
        }

        /* Write the overline */
        roman++; /* Skip first underscore */
        while (*roman != '_') {
            *(pretty_roman++) = '_';
            roman++;
        }
        *(pretty_roman++) = '\n';

        /* Copy the numeral in the second line */
        roman = roman_start;
        while (*roman != '\0') {
            if (*roman == '_') {
                roman++;
            } else {
                *(pretty_roman++) = *roman;
                roman++;
            }
        }
        *pretty_roman = '\0';
        return pretty_roman_start;
    } else {
        /* Not a long roman numeral or error */
        if (*errcode != NUMERUS_OK) {
            numerus_error_code = *errcode;
            return NULL;
        } else {
            char *roman_copy = malloc(strlen(roman) + 1);
            if (roman_copy == NULL) {
                numerus_error_code = NUMERUS_ERROR_MALLOC_FAIL;
                *errcode = NUMERUS_ERROR_MALLOC_FAIL;
                return NULL;
            }
            strcpy(roman_copy, roman);
            return roman_copy;
        }
    }
}


static short _num_greatest_common_divisor(short numerator, short denominator) {
    numerator = ABS(numerator);
    denominator = ABS(denominator);
    while (numerator != denominator) {
        if (numerator > denominator) {
            numerator -= denominator;
        } else {
            denominator -= numerator;
        }
    }
    return numerator;
}


void numerus_shorten_and_same_sign_to_parts(long *int_part, short *twelfths) {
    *int_part += *twelfths / 12;
    *twelfths = *twelfths % (short) 12;
    if (*int_part > 0 && *twelfths < 0) {
        *int_part -= 1;
        *twelfths += 12;
    } else if (*int_part < 0 && *twelfths > 0) {
        *int_part += 1;
        *twelfths -= 12;
    }
}


char *numerus_create_pretty_value_as_double(double double_value) {
    short twelfths;
    long int_part = numerus_double_to_parts(double_value, &twelfths);
    return numerus_create_pretty_value_as_parts(int_part, twelfths);
}


char *numerus_create_pretty_value_as_parts(long int_part, short twelfths) {
    char *pretty_value;
    if (twelfths == 0) {
        size_t needed_space = snprintf(NULL, 0, "%ld", int_part);
        pretty_value = malloc(needed_space + 1); /* +1 for '\0' */
        if (pretty_value == NULL) {
            numerus_error_code = NUMERUS_ERROR_MALLOC_FAIL;
            return NULL;
        }
        sprintf(pretty_value, "%ld", int_part);
    } else {
        numerus_shorten_and_same_sign_to_parts(&int_part, &twelfths);
        /* Shorten twelfth fraction */
        short gcd = _num_greatest_common_divisor(twelfths, 12);
        size_t needed_space = snprintf(NULL, 0, "%ld, %d/%d", int_part, twelfths/gcd, 12/gcd);
        pretty_value = malloc(needed_space + 1); /* +1 for '\0' */
        if (pretty_value == NULL) {
            numerus_error_code = NUMERUS_ERROR_MALLOC_FAIL;
            return NULL;
        }
        sprintf(pretty_value, "%ld, %d/%d", int_part, twelfths/gcd, 12/gcd);
    }
    return pretty_value;
}


struct _num_error_codes {
    const int code;
    const char *message;
};


static struct _num_error_codes _NUM_ERROR_CODES[] = {
    {NUMERUS_ERROR_VALUE_OUT_OF_RANGE,
            "The value to be converted to roman is out of conversion range."},
    {NUMERUS_ERROR_ILLEGAL_CHARACTER,
            "The roman numeral contains a character that is not part of the syntax of roman numerals."},
    {NUMERUS_ERROR_TOO_LONG_NUMERAL,
            "The roman numeral is too long to be syntactically correct."},
    {NUMERUS_ERROR_TOO_MANY_REPEATED_CHARS,
            "The roman numeral contains too many consecutive repetitions of a repeatable character."},
    {NUMERUS_ERROR_ILLEGAL_CHAR_SEQUENCE,
            "The roman numeral contains mispositioned characters."},
    {NUMERUS_ERROR_MISSING_SECOND_UNDERSCORE,
            "The roman numeral contains one underscore but not the second one."},
    {NUMERUS_ERROR_UNDERSCORE_AFTER_LONG_PART,
            "The long roman numeral contains one underscore after the second one."},
    {NUMERUS_ERROR_UNDERSCORE_IN_NON_LONG,
            "The non-long roman numeral contains one underscore."},
    {NUMERUS_ERROR_DECIMALS_IN_LONG_PART,
            "The long roman numeral contains decimal characters \"Ss.\" in the long part."},
    {NUMERUS_ERROR_ILLEGAL_MINUS,
            "The roman numeral contains a misplaced minus '-' or more than one."},
    {NUMERUS_ERROR_M_IN_SHORT_PART,
            "The long roman numeral contains an 'M' character after the long part."},
    {NUMERUS_ERROR_MALLOC_FAIL,
            "Heap memory allocation failure."},
    {NUMERUS_ERROR_NULL_ROMAN,
            "The pointer to the roman numeral string is NULL."},
    {NUMERUS_ERROR_EMPTY_ROMAN,
            "The roman numeral string is empty or filled with whitespace."},
    {NUMERUS_ERROR_WHITESPACE_CHARACTER,
            "The roman numeral string contains whitespace characters, even at the end."},
    {NUMERUS_OK,
            "Everything went all right."},
    {NUMERUS_ERROR_GENERIC,
            "An unknown or unspecified error happened."}
};


const char *numerus_explain_error(int error_code) {
    const struct _num_error_codes *current_code = &_NUM_ERROR_CODES[0];
    while (current_code->code != 0) {
        if (error_code == current_code->code) {
            return current_code->message;
        } else {
            current_code++;
        }
    }
    return numerus_explain_error(NUMERUS_ERROR_GENERIC);
}


double numerus_parts_to_double(long int_part, short twelfths) {
    return (double) (int_part) + twelfths / 12.0;
}


long numerus_double_to_parts(double value, short *twelfths) {
    short zero_twelfths = 0;
    if (twelfths == NULL) {
        twelfths = &zero_twelfths;
    }
    long int_part = (long) value;
    value -= int_part; /* Get only decimal part */
    value = round(value * 12) / 12; /* Round to nearest twelfth */
    value = round(value * 12); /* Get numerator of that twelfth */
    *twelfths = (short) value;
    return int_part;
}