mathio.c

Go to the documentation of this file.

#ifdef USER_CODFIG
#include "user_config.h"
#endif

#ifdef PRINTF_TEST
#include <stdio.h>
#include <stdlib.h>
#endif

#include <stdint.h>
#include <stdarg.h>
#include <string.h>

#include "mathio.h"

#include <math.h>
#undef atof

// =============================================
// MATH/IO
// =============================================

// =============================================
MEMSPACE 
int
atodigit(int c,int radix)
{
    int ret = -1;
    if(c >= '0' && c <= '9')
            ret = c - '0';
    else if(c >= 'A' && c <= 'F')
            ret = c - 'A' + 10;
    else if(c >= 'a' && c <= 'f')
            ret = c - 'a' + 10;
    else return (-1);
    return((ret >= radix) ? -1 : ret);
}

// =============================================
MEMSPACE
long atoh(const char *p)
{
    return strtol(p, (char **) NULL, 16);
}


// =============================================
MEMSPACE
long
aton(char *str, int base)
{
    unsigned long num;
    char *endptr;

    num = strtol(str, &endptr, base);
    return(num);
}

// =============================================
MEMSPACE
int mul10str(uint8_t *str, int size)
{

    uint16_t d;
    uint16_t carry = 0;
    while(size--)
    {
        d = *str;
        d <<= 1;
        d <<= 1;
        d += *str;
        d <<= 1;
        d += carry;
        *str = d & 0xff;
        carry = d >> 8;
        ++str;
    }
    return(carry);
}

// =============================================
MEMSPACE 
long
strtol(const char *nptr, char **endptr, int base)
{
    unsigned long num;
    int sign;
    int d;

    while(*nptr == ' ' || *nptr == '\t')
        ++nptr;
    sign = 0;
    if(*nptr == '-' ) 
    {
        sign = 1;
        ++nptr;
    } 
    else if(*nptr == '+' )
        {
            ++nptr;
        }
    // skip leading zeros
    while(*nptr == '0')
        ++nptr;
    num = 0;
    while(*nptr)
    {
        d = atodigit(*nptr,base);
        if(d < 0)
            break;
        num = num*base;
        num += d;
        ++nptr;
    }

    if(sign)
        num = -num;
    if(endptr)
        *endptr = (char *) nptr;
    return(num);
}

// =============================================
MEMSPACE 
long long
strtoll(const char *nptr, char **endptr, int base)
{
    unsigned long long num;
    int sign;
    int d;

    while(*nptr == ' ' || *nptr == '\t')
        ++nptr;
    sign = 0;
    if(*nptr == '-' )
    {
        sign = 1;
        ++nptr;
    }
    else if(*nptr == '+' )
        {
            ++nptr;
        }
    // skip leading zeros
    while(*nptr == '0')
        ++nptr;

    num = 0;
    while(*nptr)
    {
        d = atodigit(*nptr,base);
        if(d < 0)
            break;
        num = num*base;
        num += d;
        ++nptr;
    }
    if(sign)
        num = -num;
    if(endptr)
        *endptr = (char *) nptr;
    return(num);
}


#ifdef __SIZEOF_INT128__
// =============================================
MEMSPACE
__uint128_t
strto128(const char *nptr, char **endptr, int base)
{
    __uint128_t num;
    int sign;
    int d;

    while(*nptr == ' ' || *nptr == '\t')
        ++nptr;
    sign = 0;
    if(*nptr == '-' )
    {
        sign = 1;
        ++nptr;
    }
    else if(*nptr == '+' )
        {
            ++nptr;
        }

    // skip leading zeros
    while(*nptr == '0')
        ++nptr;

    num = 0;
    while(*nptr)
    {
        d = atodigit(*nptr,base);
        if(d < 0)
            break;
        num = num*base;
        num += d;
        ++nptr;
    }
    if(sign)
        num = -num;
    if(endptr)
        *endptr = (char *) nptr;
    return(num);
}
  
#endif 

// =============================================
MEMSPACE 
int
atoi(const char *str)
{
    unsigned long num;
    num = strtol(str, NULL, 10);
    return((int)num);
}

// =============================================
MEMSPACE 
long
atol(const char *str)
{
    unsigned long num;
    num = strtol(str, NULL, 10);
    return(num);
}

// =============================================
// Floating point I/O helper functions
// =============================================
#ifdef FLOATIO
MEMSPACE
double
iexp(double num, int exp)
{
    double a;
    if(exp==0)
        return(1.0);
    if(exp <0)
    {
        a = 1.0 / num;
        exp = 1 - exp;
    }
    else
    {
        exp = exp - 1;
        a = num;
    }
    while(exp)
    {
        if(exp & 0x01)
            num *= a;
        if(exp >>= 1)
            a *= a;
    }
    return(num);
}

// =============================================
MEMSPACE 
double
scale10(double num, int *exp)
{
    int exp10,exp2;
    int sign;

    double scale;

    if(!num)
    {
        *exp = 0;
        return(0.0);
    }

    sign = 0;
    if(num < 0)
    {
        num = -num;
        sign = 1;
    }
        
    // extract exponent
    frexp(num, &exp2);
    // aproximate exponent in base 10
    exp10 = ((double) exp2) / (double) 3.321928095;

    // convert scale to 10.0**exp10
    scale = iexp((double)10.0, exp10);

    // remove scale
    num /= scale;

    // correct for over/under
    while(num >= (double)10.0) 
    {
        num /= (double) 10.0;
        ++exp10;
    }
    while(num < (double) 1.0) 
    {
        num *= (double) 10.0;
        --exp10;
    }

    *exp = exp10;
    if(sign)
        return(-num);
    return(num);
}

// =============================================
MEMSPACE
double
strtod(const char *nptr, char **endptr)
{
    double num;
    double frac;
    double tmp;

    int digit, power,sign;

    while(*nptr == ' ' || *nptr == '\t' || *nptr == '\n')
        ++nptr;
    sign = 1;
    if(*nptr == '-')
    {
        ++nptr;
        sign = -1;
    }
    else if(*nptr == '+')
    {
        ++nptr;
    }
    // skip leading zeros
    while(*nptr == '0')
        ++nptr;
    num = 0.0; 
    while(*nptr && isdigit(*nptr)) 
    {
        num *= 10.0;    // make room for new digit
        digit = (*nptr - '0');
        num += (double) digit;
        nptr++;
    }

    if(*nptr == '.') 
    {
        ++nptr;
        frac = 0.1;
        while(*nptr && isdigit(*nptr)) 
        {
            digit = (*nptr - '0');
            tmp = (double) digit;
            num += tmp * frac;
            frac *= 0.1;
            nptr++;
        }
    }
    if(sign == -1)
        num = -num;

    if(*nptr == 'E' || *nptr == 'e') 
    {
        nptr++;
        sign = (*nptr == '-') ? -1 : 1;
        if(sign == -1 || *nptr == '+') 
            nptr++;
        power=0;
        while(isdigit(*nptr)) 
        {
            power *= 10.0;
            digit = (*nptr - '0');
            power += (double) digit; 
            nptr++;
        }
        if(num)
        {
            if(sign<0)
                power = -power;
            // iexp - number to integer power
            num *= iexp(10.0, power);
        }
    }
    if(endptr)
        *endptr = (char *) nptr;
    return(num);
}

// =============================================
MEMSPACE 
double
atof(const char *str)
{
    double num;
    num = strtod(str, NULL);
    return(num);
}
  
#endif // ifdef FLOATIO