cas.h

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <ctype.h>
#include <stdbool.h>
#include <signal.h>

#ifdef INF
#undef INF
#endif
#define INF 1.0 / 0.0

const char date[] = "18/12/2023";

typedef struct term_t term_t;
struct term_t
{
    double coef;
    double exponent;
    double division;
    double func_exponent;
    char variable;
    int function;
    term_t *t_coef;
    term_t *t_exponent;
    term_t *t_division;
    term_t **t_multiply;

    size_t t_coef_sz;
    size_t t_exponent_sz;
    size_t t_division_sz;
    size_t t_multiply_sz;
};

typedef struct domain_t
{
    double *lowbound;
    double *highbound;
    int *is_open_low;
    int *is_open_high;
    int *operation;
    size_t domcount;

    int *is_periodic;
    double *x0;
    double *period;

    double *holes;
    size_t holecount;

} domain_t;

enum Functions
{
    SIN = 1,
    COS = 2,
    TAN = 3,
    ASIN = 4,
    ACOS = 5,
    ATAN = 6,
    SEC = 7,
    CSC = 8,
    COT = 9,
    ACSC = 10,
    ASEC = 11,
    ACOT = 12,
    SINH = 13,
    COSH = 14,
    TANH = 15,
    SECH = 16,
    CSCH = 17,
    COTH = 18,
    ASINH = 19,
    ACOSH = 20,
    ATANH = 21,
    ASECH = 22,
    ACSCH = 23,
    ACOTH = 24,
    LN = 25,
    LOG = 26,
    LOG2 = 27,
    EXP = 28,
    SQRT = 29,
    GAMMA = 30, // funció Γ(x) d'Euler
    ERF = 31,   // funció d'error
    SGN = 32,   // funció de signe, definida com: -1 si x<0, 0 si x=0 i 1 si x>0
    ABS = 33,   // valor absolut
    DELTA = 34, // funció Dirac Delta, 0 si x != 0, +inf si x=0, int R = 1
    FACT = 35,  // factorial, funció gamma d'Euler pels naturals
    LB = 36,    // logaritme binari, igual que log2
    LOG10 = 37, // log10
    INV = 38,   // 1/x
};

const size_t FUNC_COUNT = 38;

double sin_fn(double x)
{
    return sin(x);
}
double cos_fn(double x)
{
    return cos(x);
}
double tan_fn(double x)
{
    return tan(x);
}
double asin_fn(double x)
{
    return asin(x);
}
double acos_fn(double x)
{
    return acos(x);
}
double atan_fn(double x)
{
    return atan(x);
}
double sec_fn(double x)
{
    return 1.0 / cos(x);
}
double csc_fn(double x)
{
    return 1.0 / sin(x);
}
double cot_fn(double x)
{
    return 1.0 / tan(x);
}
double acsc_fn(double x)
{
    return asin(1.0 / x);
}
double asec_fn(double x)
{
    return acos(1.0 / x);
}
double acot_fn(double x)
{
    return atan(1.0 / x);
}
double sinh_fn(double x)
{
    return sinh(x);
}
double cosh_fn(double x)
{
    return cosh(x);
}
double tanh_fn(double x)
{
    return tanh(x);
}
double sech_fn(double x)
{
    return 1.0 / cosh(x);
}
double csch_fn(double x)
{
    return 1.0 / sinh(x);
}
double coth_fn(double x)
{
    return 1.0 / tanh(x);
}
double asinh_fn(double x)
{
    return asinh(x);
}
double acosh_fn(double x)
{
    return acosh(x);
}
double atanh_fn(double x)
{
    return atanh(x);
}
double asech_fn(double x)
{
    return acosh(1.0 / x);
}
double acsch_fn(double x)
{
    return asinh(1.0 / x);
}
double acoth_fn(double x)
{
    return atanh(1.0 / x);
}
double ln_fn(double x)
{
    return log(x);
}
double log10_fn(double x)
{
    return log10(x);
}
double log2_fn(double x)
{
    return log2(x);
}
double exp_fn(double x)
{
    return exp(x);
}
double sqrt_fn(double x)
{
    return sqrt(x);
}
double gamma_fn(double x)
{
    return tgamma(x);
}
double erf_fn(double x)
{
    return erf(x);
}

double abs_fn(double x)
{
    return fabs(x);
}
double sgn_fn(double x)
{
    if (x < 0.0)
        return -1.0;
    else if (x > 0.0)
        return 1.0;
    else
        return 0.0;
}
double num_fn(double x)
{
    return x;
}

double delta_fn(double x)
{
    return ((x == 0) ? 1.0 / 0.0 : 0);
}
double factorial_fn(double x)
{
    if (floor(x) != x)
    {
        return NAN;
    }
    if (x < 0)
    {
        if ((int)fabs(x) % 2)
        {
            return +INF;
        }
        else
        {
            return -INF;
        }
    }
    double fact = 1;
    if (x >= 0)
    {
        for (unsigned int i = 1; i <= floor(x); i++)
        {
            fact *= i;
        }
    }
    return fact;
}

double inv_fn(double x)
{
    return 1.0 / x;
}

struct function_table
{
    char *name;
    double (*fn)(double num);
};

struct function_table func_list[] = {
    // noms de les funcions matemàtiques
    {"", num_fn},
    {"sin", sin_fn},
    {"cos", cos_fn},
    {"tan", tan_fn},
    {"arcsin", asin_fn},
    {"arccos", acos_fn},
    {"arctan", atan_fn},
    {"sec", sec_fn},
    {"csc", csc_fn},
    {"cot", cot_fn},
    {"arccsc", acsc_fn},
    {"arcsec", asec_fn},
    {"arccot", acot_fn},
    {"sinh", sinh_fn},
    {"cosh", cosh_fn},
    {"tanh", tanh_fn},
    {"sech", sech_fn},
    {"csch", csch_fn},
    {"coth", coth_fn},
    {"arcsinh", asinh_fn},
    {"arccosh", acosh_fn},
    {"arctanh", atanh_fn},
    {"arcsech", asech_fn},
    {"arccsch", acsch_fn},
    {"arccoth", acoth_fn},
    {"ln", ln_fn},
    {"log", log10_fn},
    {"log2", log2_fn},
    {"exp", exp_fn},
    {"sqrt", sqrt_fn},
    {"gamma", gamma_fn},
    {"erf", erf_fn},
    {"sgn", sgn_fn},
    {"abs", abs_fn},
    {"delta", delta_fn},
    {"fact", factorial_fn},
    {"lb", log2_fn},
    {"log10", log10_fn},
    {"inv", inv_fn},
    
};

const char cas_version[] = "1.0";

int print_func(term_t **func, size_t termcount);
double eval_func(term_t **term, double x, size_t termcount);
term_t **add_terms(term_t *f1, term_t *f2, size_t *finalsize);
term_t **multiply_terms(term_t *f1, term_t *f2);
int is_polynomial(term_t **func, size_t termcount, bool allow_func);
term_t *create_term();
term_t *parse_input(char *func, term_t *term);
int check_if_no_func(term_t **func, size_t termcount);
term_t **simp_func(term_t **func, size_t termcount, bool simplify_division);