mirror of
https://github.com/Gnucash/gnucash.git
synced 2025-02-25 18:55:30 -06:00
Priit Laes' patch for C90 compliance.
* src/engine/Scrub.c * src/engine/Scrub2.c * src/engine/gnc-numeric.c * src/engine/gnc-pricedb.c * src/engine/kvp-util.c * src/engine/qofid.c * src/engine/qofmath128.c * src/engine/qofquery.c * src/engine/qofsession.c * src/engine/test/test-numeric.c Priit Laes' patch for C90 compliance. git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/trunk@10205 57a11ea4-9604-0410-9ed3-97b8803252fd
This commit is contained in:
Derek Atkins
parent
8c83c4fb0f
commit
24b8a65adf
14
ChangeLog
14
ChangeLog
@ -1,3 +1,17 @@
|
||||
2004-07-20 Derek Atkins <derek@ihtfp.com>
|
||||
|
||||
* src/engine/Scrub.c
|
||||
* src/engine/Scrub2.c
|
||||
* src/engine/gnc-numeric.c
|
||||
* src/engine/gnc-pricedb.c
|
||||
* src/engine/kvp-util.c
|
||||
* src/engine/qofid.c
|
||||
* src/engine/qofmath128.c
|
||||
* src/engine/qofquery.c
|
||||
* src/engine/qofsession.c
|
||||
* src/engine/test/test-numeric.c
|
||||
Priit Laes' patch for C90 compliance.
|
||||
|
||||
2004-07-13 David Montenegro <sunrise2000@comcast.net>
|
||||
|
||||
* src/report/standard-reports/general-ledger.scm:
|
||||
|
||||
@ -137,6 +137,8 @@ void
|
||||
xaccTransScrubOrphans (Transaction *trans)
|
||||
{
|
||||
SplitList *node;
|
||||
QofBook *book = NULL;
|
||||
AccountGroup *root = NULL;
|
||||
for (node = trans->splits; node; node = node->next)
|
||||
{
|
||||
Split *split = node->data;
|
||||
@ -154,8 +156,8 @@ xaccTransScrubOrphans (Transaction *trans)
|
||||
* XXX we should probably *always* to this, instead of the above loop!
|
||||
*/
|
||||
PINFO ("Free Floating Transaction!");
|
||||
QofBook *book = xaccTransGetBook (trans);
|
||||
AccountGroup *root = xaccGetAccountGroup (book);
|
||||
book = xaccTransGetBook (trans);
|
||||
root = xaccGetAccountGroup (book);
|
||||
TransScrubOrphansFast (trans, root);
|
||||
}
|
||||
|
||||
@ -361,6 +363,7 @@ xaccTransScrubImbalance (Transaction *trans, AccountGroup *root,
|
||||
Account *parent)
|
||||
{
|
||||
Split *balance_split = NULL;
|
||||
QofBook *book = NULL;
|
||||
gnc_numeric imbalance;
|
||||
Account *account;
|
||||
SplitList *node, *slist;
|
||||
@ -394,7 +397,7 @@ xaccTransScrubImbalance (Transaction *trans, AccountGroup *root,
|
||||
/* This should never occur, accounts are always
|
||||
* in an account group */
|
||||
PERR ("Can't find root account");
|
||||
QofBook *book = xaccTransGetBook (trans);
|
||||
book = xaccTransGetBook (trans);
|
||||
root = xaccGetAccountGroup (book);
|
||||
}
|
||||
if (NULL == root)
|
||||
|
||||
@ -156,6 +156,7 @@ xaccLotScrubDoubleBalance (GNCLot *lot)
|
||||
{
|
||||
gnc_commodity *currency = NULL;
|
||||
SplitList *snode;
|
||||
GList *node;
|
||||
gnc_numeric zero = gnc_numeric_zero();
|
||||
gnc_numeric value = zero;
|
||||
|
||||
@ -211,7 +212,6 @@ xaccLotScrubDoubleBalance (GNCLot *lot)
|
||||
*/
|
||||
PERR ("Closed lot fails to double-balance !! lot value=%s",
|
||||
gnc_num_dbg_to_string (value));
|
||||
GList *node;
|
||||
for (node=lot->splits; node; node=node->next)
|
||||
{
|
||||
Split *s = node->data;
|
||||
|
||||
@ -82,6 +82,7 @@ gnc_numeric_check(gnc_numeric in)
|
||||
static inline gint64
|
||||
gnc_numeric_lcd(gnc_numeric a, gnc_numeric b)
|
||||
{
|
||||
qofint128 lcm;
|
||||
if(gnc_numeric_check(a) || gnc_numeric_check(b))
|
||||
{
|
||||
return GNC_ERROR_ARG;
|
||||
@ -99,7 +100,7 @@ gnc_numeric_lcd(gnc_numeric a, gnc_numeric b)
|
||||
return b.denom;
|
||||
}
|
||||
|
||||
qofint128 lcm = lcm128 (a.denom, b.denom);
|
||||
lcm = lcm128 (a.denom, b.denom);
|
||||
if (lcm.isbig) return GNC_ERROR_ARG;
|
||||
return lcm.lo;
|
||||
}
|
||||
@ -113,6 +114,7 @@ reduce128(qofint128 n, gint64 d)
|
||||
gint64 num;
|
||||
gint64 denom;
|
||||
gnc_numeric out;
|
||||
qofint128 red;
|
||||
|
||||
t = rem128 (n, d);
|
||||
num = d;
|
||||
@ -127,7 +129,7 @@ reduce128(qofint128 n, gint64 d)
|
||||
}
|
||||
/* num now holds the GCD (Greatest Common Divisor) */
|
||||
|
||||
qofint128 red = div128 (n, num);
|
||||
red = div128 (n, num);
|
||||
if (red.isbig)
|
||||
{
|
||||
return gnc_numeric_error (GNC_ERROR_OVERFLOW);
|
||||
@ -219,6 +221,7 @@ int
|
||||
gnc_numeric_compare(gnc_numeric a, gnc_numeric b)
|
||||
{
|
||||
gint64 aa, bb;
|
||||
qofint128 l, r;
|
||||
|
||||
if(gnc_numeric_check(a) || gnc_numeric_check(b))
|
||||
{
|
||||
@ -235,8 +238,8 @@ gnc_numeric_compare(gnc_numeric a, gnc_numeric b)
|
||||
if ((a.denom > 0) && (b.denom > 0))
|
||||
{
|
||||
/* Avoid overflows using 128-bit intermediate math */
|
||||
qofint128 l = mult128 (a.num, b.denom);
|
||||
qofint128 r = mult128 (b.num, a.denom);
|
||||
l = mult128 (a.num, b.denom);
|
||||
r = mult128 (b.num, a.denom);
|
||||
return cmp128 (l,r);
|
||||
}
|
||||
|
||||
@ -377,18 +380,19 @@ gnc_numeric_add(gnc_numeric a, gnc_numeric b,
|
||||
* Computing the LCD minimizes likelyhood of overflow
|
||||
*/
|
||||
gint64 lcd;
|
||||
qofint128 ca, cb, cab;
|
||||
lcd = gnc_numeric_lcd(a,b);
|
||||
if (GNC_ERROR_ARG == lcd)
|
||||
{
|
||||
return gnc_numeric_error(GNC_ERROR_OVERFLOW);
|
||||
}
|
||||
qofint128 ca = mult128 (a.num, lcd/a.denom);
|
||||
ca = mult128 (a.num, lcd/a.denom);
|
||||
if (ca.isbig) return gnc_numeric_error(GNC_ERROR_OVERFLOW);
|
||||
|
||||
qofint128 cb = mult128 (b.num, lcd/b.denom);
|
||||
cb = mult128 (b.num, lcd/b.denom);
|
||||
if (cb.isbig) return gnc_numeric_error(GNC_ERROR_OVERFLOW);
|
||||
|
||||
qofint128 cab = add128 (ca, cb);
|
||||
cab = add128 (ca, cb);
|
||||
if (cab.isbig) return gnc_numeric_error(GNC_ERROR_OVERFLOW);
|
||||
|
||||
sum.num = cab.lo;
|
||||
@ -414,12 +418,13 @@ gnc_numeric
|
||||
gnc_numeric_sub(gnc_numeric a, gnc_numeric b,
|
||||
gint64 denom, gint how)
|
||||
{
|
||||
gnc_numeric nb;
|
||||
if(gnc_numeric_check(a) || gnc_numeric_check(b))
|
||||
{
|
||||
return gnc_numeric_error(GNC_ERROR_ARG);
|
||||
}
|
||||
|
||||
gnc_numeric nb = b;
|
||||
nb = b;
|
||||
nb.num = -nb.num;
|
||||
return gnc_numeric_add (a, nb, denom, how);
|
||||
}
|
||||
@ -552,6 +557,7 @@ gnc_numeric_div(gnc_numeric a, gnc_numeric b,
|
||||
gint64 denom, gint how)
|
||||
{
|
||||
gnc_numeric quotient;
|
||||
qofint128 nume, deno;
|
||||
|
||||
if(gnc_numeric_check(a) || gnc_numeric_check(b))
|
||||
{
|
||||
@ -606,8 +612,8 @@ gnc_numeric_div(gnc_numeric a, gnc_numeric b,
|
||||
sgn = -sgn;
|
||||
b.num = -b.num;
|
||||
}
|
||||
qofint128 nume = mult128(a.num, b.denom);
|
||||
qofint128 deno = mult128(b.num, a.denom);
|
||||
nume = mult128(a.num, b.denom);
|
||||
deno = mult128(b.num, a.denom);
|
||||
|
||||
/* Try to avoid overflow by removing common factors */
|
||||
if (nume.isbig && deno.isbig)
|
||||
@ -717,6 +723,7 @@ gnc_numeric_convert(gnc_numeric in, gint64 denom, gint how)
|
||||
gint denom_neg=0;
|
||||
double ratio, logratio;
|
||||
double sigfigs;
|
||||
qofint128 nume, newm;
|
||||
|
||||
if(gnc_numeric_check(in)) {
|
||||
return gnc_numeric_error(GNC_ERROR_ARG);
|
||||
@ -813,8 +820,8 @@ gnc_numeric_convert(gnc_numeric in, gint64 denom, gint how)
|
||||
* out.num = out.num / temp.denom;
|
||||
* out.denom = denom;
|
||||
*/
|
||||
qofint128 nume = mult128 (in.num, temp.num);
|
||||
qofint128 newm = div128 (nume, temp.denom);
|
||||
nume = mult128 (in.num, temp.num);
|
||||
newm = div128 (nume, temp.denom);
|
||||
remainder = rem128 (nume, temp.denom);
|
||||
|
||||
if (newm.isbig)
|
||||
|
||||
@ -553,13 +553,14 @@ GNCPriceDB *
|
||||
gnc_pricedb_create(QofBook * book)
|
||||
{
|
||||
GNCPriceDB * result;
|
||||
QofCollection *col;
|
||||
|
||||
g_return_val_if_fail (book, NULL);
|
||||
|
||||
/* There can only be one pricedb per book. So if one exits already,
|
||||
* then use that. Warn user, they shouldn't be creating two ...
|
||||
*/
|
||||
QofCollection *col = qof_book_get_collection (book, GNC_ID_PRICEDB);
|
||||
col = qof_book_get_collection (book, GNC_ID_PRICEDB);
|
||||
result = qof_collection_get_data (col);
|
||||
if (result)
|
||||
{
|
||||
@ -584,10 +585,11 @@ destroy_pricedb_currency_hash_data(gpointer key,
|
||||
{
|
||||
GList *price_list = (GList *) data;
|
||||
GList *node;
|
||||
GNCPrice *p;
|
||||
|
||||
for (node = price_list; node; node = node->next)
|
||||
{
|
||||
GNCPrice *p = node->data;
|
||||
p = node->data;
|
||||
|
||||
p->db = NULL;
|
||||
}
|
||||
|
||||
@ -165,7 +165,7 @@ gnc_kvp_bag_remove_frame (KvpFrame *root, const char *path, KvpFrame *fr)
|
||||
static KvpFrame *
|
||||
gnc_kvp_bag_get_first (KvpFrame *root, const char * path)
|
||||
{
|
||||
KvpValue *arr;
|
||||
KvpValue *arr, *va;
|
||||
KvpValueType valtype;
|
||||
GList *node;
|
||||
|
||||
@ -182,7 +182,7 @@ gnc_kvp_bag_get_first (KvpFrame *root, const char * path)
|
||||
node = kvp_value_get_glist(arr);
|
||||
if (NULL == node) return NULL;
|
||||
|
||||
KvpValue *va = node->data;
|
||||
va = node->data;
|
||||
return kvp_value_get_frame(va);
|
||||
}
|
||||
|
||||
|
||||
@ -182,8 +182,9 @@ qof_collection_get_type (QofCollection *col)
|
||||
static void
|
||||
qof_collection_remove_entity (QofEntity *ent)
|
||||
{
|
||||
QofCollection *col;
|
||||
if (!ent) return;
|
||||
QofCollection *col = ent->collection;
|
||||
col = ent->collection;
|
||||
if (!col) return;
|
||||
g_hash_table_remove (col->hash_of_entities, &ent->guid);
|
||||
ent->collection = NULL;
|
||||
|
||||
@ -43,6 +43,13 @@ inline qofint128
|
||||
mult128 (gint64 a, gint64 b)
|
||||
{
|
||||
qofint128 prod;
|
||||
guint64 a0, a1;
|
||||
guint64 b0, b1;
|
||||
guint64 d, d0, d1;
|
||||
guint64 e, e0, e1;
|
||||
guint64 f, f0, f1;
|
||||
guint64 g, g0, g1;
|
||||
guint64 sum, carry, roll, pmax;
|
||||
|
||||
prod.isneg = 0;
|
||||
if (0>a)
|
||||
@ -57,35 +64,35 @@ mult128 (gint64 a, gint64 b)
|
||||
b = -b;
|
||||
}
|
||||
|
||||
guint64 a1 = a >> 32;
|
||||
guint64 a0 = a - (a1<<32);
|
||||
a1 = a >> 32;
|
||||
a0 = a - (a1<<32);
|
||||
|
||||
guint64 b1 = b >> 32;
|
||||
guint64 b0 = b - (b1<<32);
|
||||
b1 = b >> 32;
|
||||
b0 = b - (b1<<32);
|
||||
|
||||
guint64 d = a0*b0;
|
||||
guint64 d1 = d >> 32;
|
||||
guint64 d0 = d - (d1<<32);
|
||||
d = a0*b0;
|
||||
d1 = d >> 32;
|
||||
d0 = d - (d1<<32);
|
||||
|
||||
guint64 e = a0*b1;
|
||||
guint64 e1 = e >> 32;
|
||||
guint64 e0 = e - (e1<<32);
|
||||
e = a0*b1;
|
||||
e1 = e >> 32;
|
||||
e0 = e - (e1<<32);
|
||||
|
||||
guint64 f = a1*b0;
|
||||
guint64 f1 = f >> 32;
|
||||
guint64 f0 = f - (f1<<32);
|
||||
f = a1*b0;
|
||||
f1 = f >> 32;
|
||||
f0 = f - (f1<<32);
|
||||
|
||||
guint64 g = a1*b1;
|
||||
guint64 g1 = g >> 32;
|
||||
guint64 g0 = g - (g1<<32);
|
||||
g = a1*b1;
|
||||
g1 = g >> 32;
|
||||
g0 = g - (g1<<32);
|
||||
|
||||
guint64 sum = d1+e0+f0;
|
||||
guint64 carry = 0;
|
||||
sum = d1+e0+f0;
|
||||
carry = 0;
|
||||
/* Can't say 1<<32 cause cpp will goof it up; 1ULL<<32 might work */
|
||||
guint64 roll = 1<<30;
|
||||
roll = 1<<30;
|
||||
roll <<= 2;
|
||||
|
||||
guint64 pmax = roll-1;
|
||||
pmax = roll-1;
|
||||
while (pmax < sum)
|
||||
{
|
||||
sum -= roll;
|
||||
@ -125,7 +132,8 @@ shift128 (qofint128 x)
|
||||
inline qofint128
|
||||
shiftleft128 (qofint128 x)
|
||||
{
|
||||
guint64 sbit = x.lo & HIBIT;
|
||||
guint64 sbit;
|
||||
sbit = x.lo & HIBIT;
|
||||
x.hi <<= 1;
|
||||
x.lo <<= 1;
|
||||
x.isbig = 0;
|
||||
@ -174,6 +182,7 @@ inline qofint128
|
||||
div128 (qofint128 n, gint64 d)
|
||||
{
|
||||
qofint128 quotient;
|
||||
int i;
|
||||
guint64 remainder = 0;
|
||||
|
||||
quotient = n;
|
||||
@ -184,7 +193,6 @@ div128 (qofint128 n, gint64 d)
|
||||
}
|
||||
|
||||
/* Use grade-school long division algorithm */
|
||||
int i;
|
||||
for (i=0; i<128; i++)
|
||||
{
|
||||
guint64 sbit = HIBIT & quotient.hi;
|
||||
|
||||
@ -1216,13 +1216,13 @@ void qof_query_add_guid_match (QofQuery *q, GSList *param_list,
|
||||
|
||||
void qof_query_set_book (QofQuery *q, QofBook *book)
|
||||
{
|
||||
GSList *slist = NULL;
|
||||
if (!q || !book) return;
|
||||
|
||||
/* Make sure this book is only in the list once */
|
||||
if (g_list_index (q->books, book) == -1)
|
||||
q->books = g_list_prepend (q->books, book);
|
||||
|
||||
GSList *slist = NULL;
|
||||
g_slist_prepend (slist, QOF_PARAM_GUID);
|
||||
g_slist_prepend (slist, QOF_PARAM_BOOK);
|
||||
qof_query_add_guid_match (q, slist,
|
||||
|
||||
@ -436,6 +436,7 @@ void
|
||||
qof_session_begin (QofSession *session, const char * book_id,
|
||||
gboolean ignore_lock, gboolean create_if_nonexistent)
|
||||
{
|
||||
char * p;
|
||||
if (!session) return;
|
||||
|
||||
ENTER (" sess=%p ignore_lock=%d, book-id=%s",
|
||||
@ -471,7 +472,7 @@ qof_session_begin (QofSession *session, const char * book_id,
|
||||
* "postgres://". Everything before the colon is the access
|
||||
* method. Load the first backend found for that access method.
|
||||
*/
|
||||
char * p = strchr (book_id, ':');
|
||||
p = strchr (book_id, ':');
|
||||
if (p)
|
||||
{
|
||||
char * access_method = g_strdup (book_id);
|
||||
|
||||
@ -112,19 +112,22 @@ check_eq_operator (void)
|
||||
static void
|
||||
check_reduce (void)
|
||||
{
|
||||
gnc_numeric one, rone;
|
||||
gnc_numeric four, rfour;
|
||||
gnc_numeric val, rval;
|
||||
/* Check common factor elimination (needed for equality checks) */
|
||||
gnc_numeric one = gnc_numeric_create (1,1);
|
||||
gnc_numeric rone = gnc_numeric_create (1000000,1000000);
|
||||
one = gnc_numeric_create (1,1);
|
||||
rone = gnc_numeric_create (1000000,1000000);
|
||||
rone = gnc_numeric_reduce (rone);
|
||||
do_test (gnc_numeric_eq(one, rone), "reduce to one");
|
||||
|
||||
gnc_numeric four = gnc_numeric_create (4,1);
|
||||
gnc_numeric rfour = gnc_numeric_create (480,120);
|
||||
four = gnc_numeric_create (4,1);
|
||||
rfour = gnc_numeric_create (480,120);
|
||||
rfour = gnc_numeric_reduce (rfour);
|
||||
do_test (gnc_numeric_eq(four, rfour), "reduce to four");
|
||||
|
||||
gnc_numeric val = gnc_numeric_create(10023234LL, 334216654LL);
|
||||
gnc_numeric rval = gnc_numeric_reduce (val);
|
||||
val = gnc_numeric_create(10023234LL, 334216654LL);
|
||||
rval = gnc_numeric_reduce (val);
|
||||
check_unary_op (gnc_numeric_eq,
|
||||
gnc_numeric_create (5011617,167108327),
|
||||
rval,
|
||||
@ -150,14 +153,20 @@ check_reduce (void)
|
||||
static void
|
||||
check_equality_operator (void)
|
||||
{
|
||||
int i, m;
|
||||
gint deno, mult, numer;
|
||||
gint64 f;
|
||||
gnc_numeric big, rbig;
|
||||
gnc_numeric val, mval;
|
||||
gnc_numeric bval, rval;
|
||||
/* Check equality operator for some large numer/denom values */
|
||||
gint64 numer = 1<<30;
|
||||
numer = 1<<30;
|
||||
numer <<= 30; /* we don't trust cpp to compute 1<<60 correctly */
|
||||
gint64 deno = 1<<30;
|
||||
deno = 1<<30;
|
||||
deno <<= 20;
|
||||
gnc_numeric rbig = gnc_numeric_create (numer, deno);
|
||||
rbig = gnc_numeric_create (numer, deno);
|
||||
|
||||
gnc_numeric big = gnc_numeric_create (1<<10,1);
|
||||
big = gnc_numeric_create (1<<10,1);
|
||||
do_test (gnc_numeric_equal(big, rbig), "equal to billion");
|
||||
|
||||
big = gnc_numeric_create (1<<20,1<<10);
|
||||
@ -183,20 +192,19 @@ check_equality_operator (void)
|
||||
big = gnc_numeric_create (numer, 1<<20);
|
||||
do_test (gnc_numeric_equal(big, rbig), "equal to 1<<50/1<<20");
|
||||
|
||||
int i;
|
||||
/* We assume RAND_MAX is less that 1<<32 */
|
||||
for (i=0; i<NREPS; i++)
|
||||
{
|
||||
gint64 deno = rand() / 2;
|
||||
gint64 mult = rand() / 2;
|
||||
gint64 numer = rand() / 2;
|
||||
deno = rand() / 2;
|
||||
mult = rand() / 2;
|
||||
numer = rand() / 2;
|
||||
|
||||
gnc_numeric val = gnc_numeric_create (numer, deno);
|
||||
gnc_numeric mval = gnc_numeric_create (numer*mult, deno*mult);
|
||||
val = gnc_numeric_create (numer, deno);
|
||||
mval = gnc_numeric_create (numer*mult, deno*mult);
|
||||
|
||||
/* The reduced version should be equivalent */
|
||||
gnc_numeric bval = gnc_numeric_reduce (val);
|
||||
gnc_numeric rval = gnc_numeric_reduce (mval);
|
||||
bval = gnc_numeric_reduce (val);
|
||||
rval = gnc_numeric_reduce (mval);
|
||||
check_unary_op (gnc_numeric_eq,
|
||||
bval, rval, mval, "expected %s = %s = reduce(%s)");
|
||||
|
||||
@ -209,8 +217,8 @@ check_equality_operator (void)
|
||||
* might creep in. */
|
||||
mval.denom >>= 1;
|
||||
mval.num >>= 1;
|
||||
int m=0;
|
||||
gint64 f = mval.denom;
|
||||
m=0;
|
||||
f = mval.denom;
|
||||
while (f%2 == 0)
|
||||
{
|
||||
f >>= 1;
|
||||
@ -297,6 +305,7 @@ check_rounding (void)
|
||||
static void
|
||||
check_double (void)
|
||||
{
|
||||
double flo;
|
||||
gnc_numeric val = gnc_numeric_create (0,1);
|
||||
|
||||
check_unary_op (gnc_numeric_eq,
|
||||
@ -330,7 +339,7 @@ check_double (void)
|
||||
GNC_HOW_RND_ROUND),
|
||||
val, "expected %s = %s double 6 figs");
|
||||
|
||||
double flo = gnc_numeric_to_double(gnc_numeric_create(7, 16));
|
||||
flo = gnc_numeric_to_double(gnc_numeric_create(7, 16));
|
||||
do_test ((0.4375 == flo), "float pt conversion");
|
||||
}
|
||||
|
||||
@ -359,8 +368,14 @@ check_neg (void)
|
||||
static void
|
||||
check_add_subtract (void)
|
||||
{
|
||||
gnc_numeric a = gnc_numeric_create(2, 6);
|
||||
gnc_numeric b = gnc_numeric_create(1, 4);
|
||||
int i;
|
||||
gnc_numeric a, b, c, d, z;
|
||||
#if CHECK_ERRORS_TOO
|
||||
gnc_numeric c;
|
||||
#endif
|
||||
|
||||
a = gnc_numeric_create(2, 6);
|
||||
b = gnc_numeric_create(1, 4);
|
||||
|
||||
/* Well, actually 14/24 would be acceptable/better in this case */
|
||||
check_binary_op (gnc_numeric_create(7,12),
|
||||
@ -402,9 +417,9 @@ check_add_subtract (void)
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/* This test has failed before */
|
||||
gnc_numeric c = gnc_numeric_neg (a);
|
||||
gnc_numeric d = gnc_numeric_neg (b);
|
||||
gnc_numeric z = gnc_numeric_zero();
|
||||
c = gnc_numeric_neg (a);
|
||||
d = gnc_numeric_neg (b);
|
||||
z = gnc_numeric_zero();
|
||||
check_binary_op (c, gnc_numeric_add_fixed(z,c),
|
||||
z, c, "expected %s got %s = %s + %s for add fixed");
|
||||
|
||||
@ -455,7 +470,6 @@ check_add_subtract (void)
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
#if CHECK_ERRORS_TOO
|
||||
gnc_numeric c;
|
||||
c = gnc_numeric_add_with_error(a, b, 100, GNC_HOW_RND_ROUND, &err);
|
||||
printf("add 100ths/error : %s + %s = %s + (error) %s\n\n",
|
||||
gnc_numeric_print(a), gnc_numeric_print(b),
|
||||
@ -472,7 +486,6 @@ check_add_subtract (void)
|
||||
|
||||
/* ------------------------------------------------------------ */
|
||||
/* Add and subtract some random numbers */
|
||||
int i;
|
||||
for (i=0; i<NREPS; i++)
|
||||
{
|
||||
gnc_numeric e;
|
||||
@ -509,7 +522,11 @@ check_add_subtract (void)
|
||||
static void
|
||||
check_mult_div (void)
|
||||
{
|
||||
int i, j;
|
||||
gint64 v;
|
||||
gnc_numeric c, d;
|
||||
gnc_numeric amt_a, amt_tot, frac, val_tot, val_a;
|
||||
|
||||
gnc_numeric a = gnc_numeric_create(2, 6);
|
||||
gnc_numeric b = gnc_numeric_create(1, 4);
|
||||
|
||||
@ -556,7 +573,7 @@ check_mult_div (void)
|
||||
/* Check for math with 2^63 < num*num < 2^64 which previously failed
|
||||
* see http://bugzilla.gnome.org/show_bug.cgi?id=144980
|
||||
*/
|
||||
gint64 v = 1000000;
|
||||
v = 1000000;
|
||||
a = gnc_numeric_create(1*v, v);
|
||||
b = gnc_numeric_create(10000000*v, v);
|
||||
|
||||
@ -567,7 +584,6 @@ check_mult_div (void)
|
||||
/* Multiply some random numbers. This test presumes that
|
||||
* RAND_MAX is approx 2^32
|
||||
*/
|
||||
int i;
|
||||
for (i=0; i<NREPS; i++)
|
||||
{
|
||||
gint64 deno = 1;
|
||||
@ -588,7 +604,6 @@ check_mult_div (void)
|
||||
a, b, "expected %s got %s = %s * %s for mult exact");
|
||||
|
||||
/* Force 128-bit math to come into play */
|
||||
int j;
|
||||
for (j=1; j<31; j++)
|
||||
{
|
||||
a = gnc_numeric_create(na << j, 1<<j);
|
||||
@ -673,9 +688,9 @@ check_mult_div (void)
|
||||
c, d, "expected %s got %s = %s / %s for div round");
|
||||
|
||||
/* A simple irreducible ratio, involving negative numbers */
|
||||
gnc_numeric amt_a = gnc_numeric_create (-6005287905LL, 40595);
|
||||
gnc_numeric amt_tot = gnc_numeric_create (-8744187958LL, 40595);
|
||||
gnc_numeric frac = gnc_numeric_div (amt_a, amt_tot,
|
||||
amt_a = gnc_numeric_create (-6005287905LL, 40595);
|
||||
amt_tot = gnc_numeric_create (-8744187958LL, 40595);
|
||||
frac = gnc_numeric_div (amt_a, amt_tot,
|
||||
GNC_DENOM_AUTO, GNC_HOW_DENOM_REDUCE);
|
||||
|
||||
check_binary_op (gnc_numeric_create(6005287905LL, 8744187958LL),
|
||||
@ -683,8 +698,8 @@ check_mult_div (void)
|
||||
"expected %s got %s = %s / %s for div reduce");
|
||||
|
||||
/* Another overflow-prone condition */
|
||||
gnc_numeric val_tot = gnc_numeric_create (-4280656418LL, 19873);
|
||||
gnc_numeric val_a = gnc_numeric_mul (frac, val_tot,
|
||||
val_tot = gnc_numeric_create (-4280656418LL, 19873);
|
||||
val_a = gnc_numeric_mul (frac, val_tot,
|
||||
gnc_numeric_denom(val_tot),
|
||||
GNC_HOW_RND_ROUND| GNC_HOW_DENOM_EXACT);
|
||||
check_binary_op (gnc_numeric_create(-2939846940LL, 19873),
|
||||
|
||||
Loading…
Reference in New Issue
Block a user