13 #define Max(x, y) ((x) > (y) ? (x) : (y))
14 #define Min(x, y) ((x) < (y) ? (x) : (y))
16 #define init_var(v) memset(v,0,sizeof(numeric))
18 #define digitbuf_alloc(size) ((NumericDigit *) pgtypes_alloc(size))
19 #define digitbuf_free(buf) \
70 memset(var, 0,
sizeof(
decimal));
91 if (!isspace((
unsigned char) *(*ptr)))
104 if (!isspace((
unsigned char) *(*ptr)))
140 if (!isdigit((
unsigned char) *(*ptr)))
148 if (isdigit((
unsigned char) *(*ptr)))
150 dest->digits[
i++] = *(*ptr)++ -
'0';
156 else if (*(*ptr) ==
'.')
172 if (*(*ptr) ==
'e' || *(*ptr) ==
'E')
178 exponent = strtol(*ptr, &endptr, 10);
179 if (endptr == (*ptr))
185 if (exponent >= INT_MAX / 2 || exponent <= -(INT_MAX / 2))
190 dest->weight += (int) exponent;
191 dest->dscale -= (int) exponent;
192 if (
dest->dscale < 0)
199 if (!isspace((
unsigned char) *(*ptr)))
208 while (
dest->ndigits > 0 && *(
dest->digits) == 0)
214 if (
dest->ndigits == 0)
252 int carry = (var->
digits[
i] > 4) ? 1 : 0;
294 if (i <= var->weight && d < var->ndigits)
295 *cp++ = var->
digits[d++] +
'0';
309 if (i <= var->weight && d < var->ndigits)
310 *cp++ = var->
digits[d++] +
'0';
331 char **ptr = (endptr != NULL) ? endptr : &realptr;
419 while (w1 > w2 && i1 < var1->ndigits)
421 if (var1->
digits[i1++] != 0)
425 while (w2 > w1 && i2 < var2->ndigits)
427 if (var2->
digits[i2++] != 0)
434 while (i1 < var1->ndigits && i2 < var2->ndigits)
446 while (i1 < var1->ndigits)
448 if (var1->
digits[i1++] != 0)
451 while (i2 < var2->ndigits)
453 if (var2->
digits[i2++] != 0)
483 int var1ndigits = var1->
ndigits;
484 int var2ndigits = var2->
ndigits;
491 res_ndigits = res_rscale + res_weight + 1;
492 if (res_ndigits <= 0)
497 res_digits = res_buf;
499 i1 = res_rscale + var1->
weight + 1;
500 i2 = res_rscale + var2->
weight + 1;
501 for (
i = res_ndigits - 1;
i >= 0;
i--)
505 if (i1 >= 0 && i1 < var1ndigits)
506 carry += var1digits[i1];
507 if (i2 >= 0 && i2 < var2ndigits)
508 carry += var2digits[i2];
512 res_digits[
i] = carry - 10;
517 res_digits[
i] = carry;
522 while (res_ndigits > 0 && *res_digits == 0)
528 while (res_ndigits > 0 && res_digits[res_ndigits - 1] == 0)
531 if (res_ndigits == 0)
536 result->
buf = res_buf;
537 result->
digits = res_digits;
538 result->
weight = res_weight;
539 result->
rscale = res_rscale;
540 result->
dscale = res_dscale;
571 int var1ndigits = var1->
ndigits;
572 int var2ndigits = var2->
ndigits;
576 res_weight = var1->
weight;
579 res_ndigits = res_rscale + res_weight + 1;
580 if (res_ndigits <= 0)
585 res_digits = res_buf;
587 i1 = res_rscale + var1->
weight + 1;
588 i2 = res_rscale + var2->
weight + 1;
589 for (
i = res_ndigits - 1;
i >= 0;
i--)
593 if (i1 >= 0 && i1 < var1ndigits)
594 borrow += var1digits[i1];
595 if (i2 >= 0 && i2 < var2ndigits)
596 borrow -= var2digits[i2];
600 res_digits[
i] = borrow + 10;
605 res_digits[
i] = borrow;
610 while (res_ndigits > 0 && *res_digits == 0)
616 while (res_ndigits > 0 && res_digits[res_ndigits - 1] == 0)
619 if (res_ndigits == 0)
624 result->
buf = res_buf;
625 result->
digits = res_digits;
626 result->
weight = res_weight;
627 result->
rscale = res_rscale;
628 result->
dscale = res_dscale;
653 if (
add_abs(var1, var2, result) != 0)
681 if (
sub_abs(var1, var2, result) != 0)
692 if (
sub_abs(var2, var1, result) != 0)
727 if (
sub_abs(var1, var2, result) != 0)
738 if (
sub_abs(var2, var1, result) != 0)
751 if (
add_abs(var1, var2, result) != 0)
783 if (
add_abs(var1, var2, result) != 0)
813 if (
sub_abs(var1, var2, result) != 0)
824 if (
sub_abs(var2, var1, result) != 0)
859 if (
sub_abs(var1, var2, result) != 0)
870 if (
sub_abs(var2, var1, result) != 0)
883 if (
add_abs(var1, var2, result) != 0)
923 res_digits = res_buf;
924 memset(res_digits, 0, res_ndigits);
927 for (i1 = var1->
ndigits - 1; i1 >= 0; i1--)
932 for (i2 = var2->
ndigits - 1; i2 >= 0; i2--)
935 res_digits[
i--] = sum % 10;
941 i = res_weight + global_rscale + 2;
942 if (
i >= 0 &&
i < res_ndigits)
944 sum = (res_digits[
i] > 4) ? 1 : 0;
949 sum += res_digits[
i];
950 res_digits[
i--] = sum % 10;
955 while (res_ndigits > 0 && *res_digits == 0)
961 while (res_ndigits > 0 && res_digits[res_ndigits - 1] == 0)
964 if (res_ndigits == 0)
971 result->
buf = res_buf;
972 result->
digits = res_digits;
974 result->
weight = res_weight;
975 result->
rscale = global_rscale;
976 result->
sign = res_sign;
1015 firstdigit1 = var1->
digits[
i];
1016 if (firstdigit1 != 0)
1027 firstdigit2 = var2->
digits[
i];
1028 if (firstdigit2 != 0)
1039 qweight = weight1 - weight2;
1040 if (firstdigit1 <= firstdigit2)
1045 res_dscale =
Max(res_dscale, var1->
dscale);
1046 res_dscale =
Max(res_dscale, var2->
dscale);
1051 *rscale = res_dscale + 4;
1073 int first_nextdigit;
1083 ndigits_tmp = var2->
ndigits + 1;
1084 if (ndigits_tmp == 1)
1098 res_ndigits = rscale + res_weight;
1099 if (res_ndigits <= 0)
1116 for (
i = 1;
i < 10;
i++)
1122 divisor[1].
ndigits = ndigits_tmp;
1126 if (divisor[1].
buf == NULL)
1129 divisor[1].
digits[0] = 0;
1130 memcpy(&(divisor[1].
digits[1]), var2->
digits, ndigits_tmp - 1);
1140 if (dividend.
buf == NULL)
1151 if (tmp_buf == NULL)
1154 result->
buf = tmp_buf;
1155 res_digits = result->
buf;
1156 result->
digits = res_digits;
1157 result->
ndigits = res_ndigits;
1158 result->
weight = res_weight;
1160 result->
sign = res_sign;
1163 first_div = divisor[1].
digits[1] * 10;
1164 if (ndigits_tmp > 2)
1165 first_div += divisor[1].
digits[2];
1168 first_nextdigit = 0;
1171 rscale_tmp = divisor[1].
rscale;
1173 for (ri = 0; ri <= res_ndigits; ri++)
1175 first_have = first_have * 10;
1176 if (first_nextdigit >= 0 && first_nextdigit < dividend.
ndigits)
1177 first_have += dividend.
digits[first_nextdigit];
1180 guess = (first_have * 10) / first_div + 1;
1186 if (divisor[guess].
buf == NULL)
1191 memcpy(&divisor[guess], &divisor[1],
sizeof(
numeric));
1193 if (divisor[guess].
buf == NULL)
1195 divisor[guess].
digits = divisor[guess].
buf;
1196 for (
i = divisor[1].ndigits - 1;
i >= 0;
i--)
1198 sum += divisor[1].
digits[
i] * guess;
1199 divisor[guess].
digits[
i] = sum % 10;
1204 divisor[guess].
weight = weight_tmp;
1205 divisor[guess].
rscale = rscale_tmp;
1214 res_digits[ri + 1] = guess;
1227 if (
sub_abs(÷nd, &divisor[guess], ÷nd) != 0)
1230 first_nextdigit = dividend.
weight - weight_tmp;
1232 if (first_nextdigit >= 0 && first_nextdigit < dividend.
ndigits)
1233 first_have = dividend.
digits[first_nextdigit];
1238 if (ri == res_ndigits + 1)
1240 int carry = (res_digits[ri] > 4) ? 1 : 0;
1245 while (carry && ri > 0)
1247 carry += res_digits[--ri];
1248 res_digits[ri] = carry % 10;
1264 result->
dscale = res_dscale;
1272 if (dividend.
buf != NULL)
1275 for (
i = 1;
i < 10;
i++)
1277 if (divisor[
i].
buf != NULL)
1317 signed long int long_int = int_val;
1335 signed long int abs_long_val = long_val;
1336 signed long int extract;
1337 signed long int reach_limit;
1339 if (abs_long_val < 0)
1352 }
while (reach_limit - 1 < abs_long_val && reach_limit <= LONG_MAX / 10);
1354 if (reach_limit > LONG_MAX / 10)
1376 extract = abs_long_val - (abs_long_val % reach_limit);
1377 var->
digits[
i] = extract / reach_limit;
1378 abs_long_val -= extract;
1387 }
while (abs_long_val > 0);
1418 char buffer[DBL_DIG + 100];
1422 if (
sprintf(buffer,
"%.*g", DBL_DIG, d) <= 0)
1444 if (varcopy == NULL)
1463 val = strtod(tmp, &endptr);
1464 if (errno == ERANGE)
1475 if (*endptr !=
'\0')
1508 #if SIZEOF_LONG > SIZEOF_INT
1510 if (l < INT_MIN || l > INT_MAX)
1532 *lp = strtol(s, &endptr, 10);
1540 if (errno == ERANGE)
1542 if (*lp == LONG_MIN)
char * pgtypes_alloc(long size)
int PGTYPESnumeric_from_double(double d, numeric *dst)
#define digitbuf_free(buf)
int PGTYPESnumeric_copy(numeric *src, numeric *dst)
#define digitbuf_alloc(size)
static int set_var_from_str(char *str, char **ptr, numeric *dest)
int PGTYPESnumeric_from_decimal(decimal *src, numeric *dst)
int PGTYPESnumeric_to_decimal(numeric *src, decimal *dst)
void PGTYPESdecimal_free(decimal *var)
int PGTYPESnumeric_mul(numeric *var1, numeric *var2, numeric *result)
int PGTYPESnumeric_to_long(numeric *nv, long *lp)
static int numericvar_to_double(numeric *var, double *dp)
int PGTYPESnumeric_to_double(numeric *nv, double *dp)
int PGTYPESnumeric_from_long(signed long int long_val, numeric *var)
int PGTYPESnumeric_to_int(numeric *nv, int *ip)
static char * get_str_from_var(numeric *var, int dscale)
char * PGTYPESnumeric_to_asc(numeric *num, int dscale)
numeric * PGTYPESnumeric_new(void)
int PGTYPESnumeric_from_int(signed int int_val, numeric *var)
static int alloc_var(numeric *var, int ndigits)
static int select_div_scale(numeric *var1, numeric *var2, int *rscale)
int PGTYPESnumeric_sub(numeric *var1, numeric *var2, numeric *result)
decimal * PGTYPESdecimal_new(void)
static int sub_abs(numeric *var1, numeric *var2, numeric *result)
static int add_abs(numeric *var1, numeric *var2, numeric *result)
static void zero_var(numeric *var)
numeric * PGTYPESnumeric_from_asc(char *str, char **endptr)
void PGTYPESnumeric_free(numeric *var)
int PGTYPESnumeric_cmp(numeric *var1, numeric *var2)
int PGTYPESnumeric_div(numeric *var1, numeric *var2, numeric *result)
int PGTYPESnumeric_add(numeric *var1, numeric *var2, numeric *result)
static int cmp_abs(numeric *var1, numeric *var2)
#define NUMERIC_MAX_DISPLAY_SCALE
#define NUMERIC_MIN_SIG_DIGITS
#define NUMERIC_MIN_DISPLAY_SCALE
#define PGTYPES_NUM_BAD_NUMERIC
#define PGTYPES_NUM_OVERFLOW
#define PGTYPES_NUM_UNDERFLOW
#define PGTYPES_NUM_DIVIDE_ZERO
int pg_strncasecmp(const char *s1, const char *s2, size_t n)
NumericDigit digits[DECSIZE]