fixed_point.h

Go to the documentation of this file.

/* Some compilers, such as GCC, support the "extern inline" definition which
 * allows the inlining version of functions to be defined in the header. This
 * leaves to the decision of where to inline to the compiler (or to the user by
 * means of compiler switches). For those with less advanced compilers, they
 * have to  choose: either have the routines in a different module and do
 * zero inlining or include them in ALL source files with the "static" keyword
 * so one may have inlining and optimizations.
 */

#include <stdbool.h>
#include "../fixed_point.h"

FXP_SCMP(f_gt, >)


FXP_SCMP(f_ge, >=)

FXP_SCMP(f_lt, <)

FXP_SCMP(f_le, <=)

FXP_SCMP(f_eq, ==)

FXP_DCMP(df_gt, >)

FXP_DCMP(df_ge, >=)

FXP_DCMP(df_lt, <)

FXP_DCMP(df_le, <=)

FXP_DCMP(df_eq, ==)

FXP_OP3(f_add, frac, +)

FXP_OP3(f_sub, frac, -)

FXP_OP3(df_add, dfrac, +)

FXP_OP3(df_sub, dfrac, -)

FXP_OP3(ef_add, efrac, +)

FXP_OP3(ef_sub, efrac, -)

FXP_DECLARATION(efrac ef_f_add(efrac a, frac b))
{
        a.v += b.v;
        return a;
}

FXP_DECLARATION(frac f_neg(frac a))
{
        frac r = {-a.v};
        return r;
}

FXP_DECLARATION(dfrac df_neg(dfrac a))
{
        dfrac r = {-a.v};
        return r;
}

FXP_DECLARATION(efrac ef_neg(efrac a))
{
        efrac r = {-a.v};
        return r;
}

FXP_DECLARATION(frac f_mul(frac a, frac b))
{
        frac r = {((((dfrac_base)a.v) * b.v) << 1) >> FRAC_BIT};
        return r;
}

FXP_DECLARATION(dfrac f_mul_df(frac a, frac b))
{
        dfrac r = {(((dfrac_base)a.v) * b.v)};
        return r;
}

FXP_DECLARATION(efrac f_mf_mul_ef(frac a, mfrac b))
{
        efrac r = {(((efrac_base)a.v) * b.v)>>8};
        return r;
}

FXP_DECLARATION(frac f_imul(frac a, int16_t b))
{
        frac r = { a.v * b };
        return r;
}

FXP_DECLARATION(int f_imul_i(frac a, int b))
{
        return (((int64_t)b)*a.v) >> 15;
}

FXP_DECLARATION(efrac f_imul_ef(frac a, int16_t b))
{
        efrac r = { ((efrac_base)a.v) * b };
        return r;
}

FXP_DECLARATION(dfrac df_imul(dfrac a, int16_t b))
{
        dfrac r = { a.v * b };
        return r;
}

FXP_DECLARATION(efrac ef_imul(efrac a, int16_t b))
{
        efrac r = { a.v * b };
        return r;
}

FXP_DECLARATION(frac f_idiv(frac a, int16_t b))
{
        frac r = { a.v / b };
        return r;
}

FXP_DECLARATION(dfrac df_idiv(dfrac a, int16_t b))
{
        dfrac r = { a.v / b };
        return r;
}

FXP_DECLARATION(efrac ef_idiv(efrac a, int16_t b))
{
        efrac r = { a.v / b };
        return r;
}

FXP_DECLARATION(dfrac df_shiftl(dfrac a, int16_t b))
{
        dfrac r = { a.v << b };
        return r;
}

FXP_DECLARATION(dfrac df_shiftr(dfrac a, int16_t b))
{
        dfrac r = { a.v >> b };
        return r;
}

FXP_DECLARATION(frac df_to_f(dfrac x))
{ /* 2.30 -> 1.15 */
        frac r;

        if (x.v >= DFRAC_1_V)
                r.v = FRAC_1_V;
        else if ( x.v < DFRAC_minus1_V)
                r.v = FRAC_minus1_V;
        else
                r.v = (x.v << 1) >> FRAC_BIT;

        return r;
}

FXP_DECLARATION(dfrac f_to_df(frac x))
{ /* 1.15 -> 2.30 */
        dfrac r = { ((dfrac_base)x.v)<<(FRAC_BIT - 1) };
        return r;
}

FXP_DECLARATION(efrac f_to_ef(frac x))
{
        efrac r = {((efrac_base)x.v)};
        return r;
}

FXP_DECLARATION(efrac f_ef_div(frac dividend, efrac divisor))
{
        /* When dividing, the implicit divisors (2**(FRAC_BIT-1)) cancel out,
         * and we get the ratio as an integer. To get a efrac we must multiply
         * the divident by 2**(FRAC_BIT-1) BEFORE taking the quotient */
        efrac_base new_dividend = f_to_ef(dividend).v << (FRAC_BIT - 1);
        efrac r = {new_dividend/divisor.v};

        return r;
}

FXP_DECLARATION(frac ef_to_f(efrac x))
{
        frac r = { (x.v > FRAC_minus1_V)?
                        ((x.v < FRAC_1_V)? x.v : FRAC_1_V)
                        : FRAC_minus1_V
                };
        return r;
}

FXP_DECLARATION(frac f_clip (frac x, frac limit))
{

        frac r = {(x.v > -limit.v)? ((x.v < limit.v)? x.v : limit.v) : -limit.v};

        return r;
}

FXP_DECLARATION(dfrac df_addsat(dfrac x1, dfrac x2))
{
        dfrac_base result = x1.v + x2.v;
        dfrac r;

        if (x1.v > 0 && x2.v > 0)
                r.v = ((result < x1.v) ? DFRAC_MAX_V : result);
        else if (x1.v < 0 && x2.v < 0)
                r.v = ((result > x1.v) ? DFRAC_MIN_V : result);
        else
                r.v = result;

        return r;
}

FXP_DECLARATION(dfrac f_macs_df (frac x, frac y, dfrac z))
{
        return df_addsat(z, f_mul_df(x,y));
}