gnc-numeric.h

Go to the documentation of this file.

/********************************************************************
 * gnc-numeric.h - A rational number library                        *
 * This program is free software; you can redistribute it and/or    *
 * modify it under the terms of the GNU General Public License as   *
 * published by the Free Software Foundation; either version 2 of   *
 * the License, or (at your option) any later version.              *
 *                                                                  *
 * This program is distributed in the hope that it will be useful,  *
 * but WITHOUT ANY WARRANTY; without even the implied warranty of   *
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the    *
 * GNU General Public License for more details.                     *
 *                                                                  *
 * You should have received a copy of the GNU General Public License*
 * along with this program; if not, contact:                        *
 *                                                                  *
 * Free Software Foundation           Voice:  +1-617-542-5942       *
 * 51 Franklin Street, Fifth Floor    Fax:    +1-617-542-2652       *
 * Boston, MA  02110-1301,  USA       gnu@gnu.org                   *
 *                                                                  *
 *******************************************************************/

#ifndef GNC_NUMERIC_H
#define GNC_NUMERIC_H

#include <glib-object.h>

struct _gnc_numeric
{
    gint64  num;
    gint64  denom;
};

typedef struct _gnc_numeric gnc_numeric;

#define GNC_NUMERIC_RND_MASK     0x0000000f
#define GNC_NUMERIC_DENOM_MASK   0x000000f0
#define GNC_NUMERIC_SIGFIGS_MASK 0x0000ff00

enum
{
    GNC_HOW_RND_FLOOR            = 0x01,

    GNC_HOW_RND_CEIL             = 0x02,

    GNC_HOW_RND_TRUNC            = 0x03,

    GNC_HOW_RND_PROMOTE          = 0x04,

    GNC_HOW_RND_ROUND_HALF_DOWN  = 0x05,

    GNC_HOW_RND_ROUND_HALF_UP    = 0x06,

    GNC_HOW_RND_ROUND            = 0x07,

    GNC_HOW_RND_NEVER            = 0x08
};

enum
{
    GNC_HOW_DENOM_EXACT  = 0x10,

    GNC_HOW_DENOM_REDUCE = 0x20,

    GNC_HOW_DENOM_LCD    = 0x30,

    GNC_HOW_DENOM_FIXED  = 0x40,

    GNC_HOW_DENOM_SIGFIG = 0x50
};

#define GNC_HOW_DENOM_SIGFIGS( n ) ( ((( n ) & 0xff) << 8) | GNC_HOW_DENOM_SIGFIG)
#define GNC_HOW_GET_SIGFIGS( a ) ( (( a ) & 0xff00 ) >> 8)

typedef enum
{
    GNC_ERROR_OK         =  0,   
    GNC_ERROR_ARG        = -1,   
    GNC_ERROR_OVERFLOW   = -2,   
    GNC_ERROR_DENOM_DIFF = -3,

    GNC_ERROR_REMAINDER  = -4
} GNCNumericErrorCode;


#define GNC_DENOM_AUTO 0

#define GNC_DENOM_RECIPROCAL( a ) (- ( a ))

static inline
gnc_numeric gnc_numeric_create(gint64 num, gint64 denom)
{
    gnc_numeric out;
    out.num = num;
    out.denom = denom;
    return out;
}

static inline
gnc_numeric gnc_numeric_zero(void)
{
    return gnc_numeric_create(0, 1);
}

gnc_numeric double_to_gnc_numeric(double n, gint64 denom,
                                  gint how);

gboolean string_to_gnc_numeric(const gchar* str, gnc_numeric *n);

gnc_numeric gnc_numeric_error(GNCNumericErrorCode error_code);

const char* gnc_numeric_errorCode_to_string(GNCNumericErrorCode error_code);
static inline
gint64 gnc_numeric_num(gnc_numeric a)
{
    return a.num;
}
static inline
gint64 gnc_numeric_denom(gnc_numeric a)
{
    return a.denom;
}

gdouble      gnc_numeric_to_double(gnc_numeric n);

gchar *gnc_numeric_to_string(gnc_numeric n);

gchar * gnc_num_dbg_to_string(gnc_numeric n);
GNCNumericErrorCode  gnc_numeric_check(gnc_numeric a);

gint gnc_numeric_compare(gnc_numeric a, gnc_numeric b);

gboolean gnc_numeric_zero_p(gnc_numeric a);

gboolean gnc_numeric_negative_p(gnc_numeric a);

gboolean gnc_numeric_positive_p(gnc_numeric a);

gboolean gnc_numeric_eq(gnc_numeric a, gnc_numeric b);

gboolean gnc_numeric_equal(gnc_numeric a, gnc_numeric b);

gint gnc_numeric_same(gnc_numeric a, gnc_numeric b,
                      gint64 denom, gint how);
gnc_numeric gnc_numeric_add(gnc_numeric a, gnc_numeric b,
                            gint64 denom, gint how);

gnc_numeric gnc_numeric_sub(gnc_numeric a, gnc_numeric b,
                            gint64 denom, gint how);

gnc_numeric gnc_numeric_mul(gnc_numeric a, gnc_numeric b,
                            gint64 denom, gint how);

gnc_numeric gnc_numeric_div(gnc_numeric x, gnc_numeric y,
                            gint64 denom, gint how);
gnc_numeric gnc_numeric_neg(gnc_numeric a);

gnc_numeric gnc_numeric_abs(gnc_numeric a);

static inline
gnc_numeric gnc_numeric_add_fixed(gnc_numeric a, gnc_numeric b)
{
    return gnc_numeric_add(a, b, GNC_DENOM_AUTO,
                           GNC_HOW_DENOM_FIXED | GNC_HOW_RND_NEVER);
}

static inline
gnc_numeric gnc_numeric_sub_fixed(gnc_numeric a, gnc_numeric b)
{
    return gnc_numeric_sub(a, b, GNC_DENOM_AUTO,
                           GNC_HOW_DENOM_FIXED | GNC_HOW_RND_NEVER);
}
gnc_numeric gnc_numeric_add_with_error(gnc_numeric a, gnc_numeric b,
                                       gint64 denom, gint how,
                                       gnc_numeric * error);

gnc_numeric gnc_numeric_sub_with_error(gnc_numeric a, gnc_numeric b,
                                       gint64 denom, gint how,
                                       gnc_numeric * error);

gnc_numeric gnc_numeric_mul_with_error(gnc_numeric a, gnc_numeric b,
                                       gint64 denom, gint how,
                                       gnc_numeric * error);

gnc_numeric gnc_numeric_div_with_error(gnc_numeric a, gnc_numeric b,
                                       gint64 denom, gint how,
                                       gnc_numeric * error);
gnc_numeric gnc_numeric_convert(gnc_numeric n, gint64 denom,
                                gint how);

#if 0
/* Implementation missing! */
/* Same as gnc_numeric_convert, but return a remainder
 *  value for accumulating conversion error.
*/
gnc_numeric gnc_numeric_convert_with_error(gnc_numeric n, gint64 denom,
        gint how,
        gnc_numeric * error);
#endif

gnc_numeric gnc_numeric_reduce(gnc_numeric n);

gboolean gnc_numeric_to_decimal(gnc_numeric * a,
                                guint8 * max_decimal_places);
GType gnc_numeric_get_type( void );
#define GNC_TYPE_NUMERIC (gnc_numeric_get_type ())

#endif