← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/decimal.cc

  • Committer: lbieber
  • Date: 2010-09-11 16:33:45 UTC
  • mfrom: (1757.1.2 build)
  • Revision ID: lbieber@orisndriz03-20100911163345-na1t8m18at9thsjl
Merge Vijay - added utf 8 tamil test case suite and test case for creating a database in tamil
Merge Brian - Small set of refactoring (includes one case of memset on a table object).

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/decimal.cc
11
11
 
12
12
   You should have received a copy of the GNU General Public License
13
13
   along with this program; if not, write to the Free Software
14
 
   Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA */
15
 
 
16
 
/** @file
17
 
 *
18
 
 * @brief  SQL standard-compliant decimal number handling
19
 
 *
20
 
 * @note
21
 
 * This library implements SQL standard "exact numeric" type
22
 
 * and is not at all generic, but rather intentinally crippled to
23
 
 * follow the standard :) 
24
 
 */
 
14
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
25
15
 
26
16
/*
27
17
=======================================================================
 
18
  NOTE: this library implements SQL standard "exact numeric" type
 
19
  and is not at all generic, but rather intentinally crippled to
 
20
  follow the standard :)
 
21
=======================================================================
28
22
  Quoting the standard
29
23
  (SQL:2003, Part 2 Foundations, aka ISO/IEC 9075-2:2003)
30
24
 
108
102
#include "drizzled/definitions.h"
109
103
#include "drizzled/internal/m_string.h"
110
104
#include "drizzled/charset_info.h"
111
 
#include "drizzled/type/decimal.h"
 
105
#include "drizzled/decimal.h"
112
106
 
113
107
#include <plugin/myisam/myisampack.h>
114
108
#include <drizzled/util/test.h>
157
151
                        "DECIMAL", "");
158
152
    break;
159
153
  case E_DEC_DIV_ZERO:
160
 
    my_error(ER_DIVISION_BY_ZERO, MYF(0));
 
154
    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
 
155
                        ER_DIVISION_BY_ZERO, ER(ER_DIVISION_BY_ZERO));
161
156
    break;
162
157
  case E_DEC_BAD_NUM:
163
158
    push_warning_printf(current_session, DRIZZLE_ERROR::WARN_LEVEL_ERROR,
178
173
/**
179
174
  @brief Converting decimal to string
180
175
 
181
 
  @details Convert given type::Decimal to String; allocate buffer as needed.
 
176
  @details Convert given my_decimal to String; allocate buffer as needed.
182
177
 
183
178
  @param[in]   mask        what problems to warn on (mask of E_DEC_* values)
184
179
  @param[in]   d           the decimal to print
187
182
  @param[in]   filler      what char to pad with (ZEROFILL et al.)
188
183
  @param[out]  *str        where to store the resulting string
189
184
 
190
 
  @return error code
 
185
  @return error coce
191
186
    @retval E_DEC_OK
192
187
    @retval E_DEC_TRUNCATED
193
188
    @retval E_DEC_OVERFLOW
194
189
    @retval E_DEC_OOM
195
190
*/
196
191
 
197
 
int class_decimal2string(const type::Decimal *d,
198
 
                         uint32_t fixed_dec, String *str)
 
192
int my_decimal2string(uint32_t mask, const my_decimal *d,
 
193
                      uint32_t fixed_prec, uint32_t fixed_dec,
 
194
                      char filler, String *str)
199
195
{
200
 
  uint32_t mask= E_DEC_FATAL_ERROR;
201
 
 
202
196
  /*
203
197
    Calculate the size of the string: For DECIMAL(a,b), fixed_prec==a
204
198
    holds true iff the type is also ZEROFILL, which in turn implies
207
201
    one if the user only wanted decimal places, but we force a leading
208
202
    zero on them. Because the type is implicitly UNSIGNED, we do not
209
203
    need to reserve a character for the sign. For all other cases,
210
 
    fixed_prec will be 0, and class_decimal_string_length() will be called
 
204
    fixed_prec will be 0, and my_decimal_string_length() will be called
211
205
    instead to calculate the required size of the buffer.
212
206
  */
213
 
  int length= (int)(0
214
 
                    ? (uint32_t)(((0 == fixed_dec) ? 1 : 0) + 1)
215
 
                    : (uint32_t)d->string_length());
 
207
  int length= (fixed_prec
 
208
               ? (fixed_prec + ((fixed_prec == fixed_dec) ? 1 : 0) + 1)
 
209
               : my_decimal_string_length(d));
216
210
  int result;
217
211
  if (str->alloc(length))
218
212
    return check_result(mask, E_DEC_OOM);
219
 
 
220
213
  result= decimal2string((decimal_t*) d, (char*) str->ptr(),
221
 
                         &length, (int)0, fixed_dec,
222
 
                         '0');
 
214
                         &length, (int)fixed_prec, fixed_dec,
 
215
                         filler);
223
216
  str->length(length);
224
217
  return check_result(mask, result);
225
218
}
226
219
 
227
220
 
228
 
/**
229
 
  @brief  Convert from decimal to binary representation
230
 
 
231
 
  @param[in]   mask        error processing mask
232
 
  @param[in]   d           number for conversion
233
 
  @param[out]  bin         pointer to buffer where to write result
234
 
  @param[in]   prec        overall number of decimal digits
235
 
  @param[in]   scale       number of decimal digits after decimal point
236
 
 
237
 
  @note
 
221
/*
 
222
  Convert from decimal to binary representation
 
223
 
 
224
  SYNOPSIS
 
225
    my_decimal2binary()
 
226
    mask        error processing mask
 
227
    d           number for conversion
 
228
    bin         pointer to buffer where to write result
 
229
    prec        overall number of decimal digits
 
230
    scale       number of decimal digits after decimal point
 
231
 
 
232
  NOTE
238
233
    Before conversion we round number if it need but produce truncation
239
234
    error in this case
240
235
 
241
 
  @return error code
242
 
   @retval E_DEC_OK
243
 
   @retval E_DEC_TRUNCATED
244
 
   @retval E_DEC_OVERFLOW
 
236
  RETURN
 
237
    E_DEC_OK
 
238
    E_DEC_TRUNCATED
 
239
    E_DEC_OVERFLOW
245
240
*/
246
241
 
247
 
namespace type {
248
 
 
249
 
int Decimal::val_binary(uint32_t mask, unsigned char *bin, int prec, int scale) const
 
242
int my_decimal2binary(uint32_t mask, const my_decimal *d, unsigned char *bin, int prec,
 
243
                      int scale)
250
244
{
251
245
  int err1= E_DEC_OK, err2;
252
 
  type::Decimal rounded;
253
 
  class_decimal2decimal(this, &rounded);
 
246
  my_decimal rounded;
 
247
  my_decimal2decimal(d, &rounded);
254
248
  rounded.frac= decimal_actual_fraction(&rounded);
255
249
  if (scale < rounded.frac)
256
250
  {
264
258
  return check_result(mask, err2);
265
259
}
266
260
 
267
 
} // namespace type
268
 
 
269
 
 
270
 
/**
271
 
  @brief Convert string for decimal when string can be in some multibyte charset
272
 
 
273
 
  @param  mask            error processing mask
274
 
  @param  from            string to process
275
 
  @param  length          length of given string
276
 
  @param  charset         charset of given string
277
 
 
278
 
  @return Error code
279
 
   @retval E_DEC_OK
280
 
   @retval E_DEC_TRUNCATED
281
 
   @retval E_DEC_OVERFLOW
282
 
   @retval E_DEC_BAD_NUM
283
 
   @retval E_DEC_OOM
 
261
 
 
262
/*
 
263
  Convert string for decimal when string can be in some multibyte charset
 
264
 
 
265
  SYNOPSIS
 
266
    str2my_decimal()
 
267
    mask            error processing mask
 
268
    from            string to process
 
269
    length          length of given string
 
270
    charset         charset of given string
 
271
    decimal_value   buffer for result storing
 
272
 
 
273
  RESULT
 
274
    E_DEC_OK
 
275
    E_DEC_TRUNCATED
 
276
    E_DEC_OVERFLOW
 
277
    E_DEC_BAD_NUM
 
278
    E_DEC_OOM
284
279
*/
285
280
 
286
 
int type::Decimal::store(uint32_t mask, const char *from, uint32_t length, const CHARSET_INFO * charset)
 
281
int str2my_decimal(uint32_t mask, const char *from, uint32_t length,
 
282
                   const CHARSET_INFO * charset, my_decimal *decimal_value)
287
283
{
288
284
  char *end, *from_end;
289
285
  int err;
291
287
  String tmp(buff, sizeof(buff), &my_charset_bin);
292
288
  if (charset->mbminlen > 1)
293
289
  {
294
 
    size_t dummy_errors;
 
290
    uint32_t dummy_errors;
295
291
    tmp.copy(from, length, charset, &my_charset_utf8_general_ci, &dummy_errors);
296
292
    from= tmp.ptr();
297
293
    length=  tmp.length();
298
294
    charset= &my_charset_bin;
299
295
  }
300
296
  from_end= end= (char*) from+length;
301
 
  err= string2decimal((char *)from, (decimal_t*) this, &end);
 
297
  err= string2decimal((char *)from, (decimal_t*) decimal_value, &end);
302
298
  if (end != from_end && !err)
303
299
  {
304
300
    /* Give warning if there is something other than end space */
311
307
      }
312
308
    }
313
309
  }
314
 
  check_result_and_overflow(mask, err);
 
310
  check_result_and_overflow(mask, err, decimal_value);
315
311
  return err;
316
312
}
317
313
 
318
 
void type::Decimal::convert(double &result) const
319
 
{
320
 
  decimal2double(static_cast<const decimal_t*>(this), &result);
321
 
}
322
314
 
323
 
type::Decimal *date2_class_decimal(type::Time *ltime, type::Decimal *dec)
 
315
my_decimal *date2my_decimal(DRIZZLE_TIME *ltime, my_decimal *dec)
324
316
{
325
317
  int64_t date;
326
318
  date = (ltime->year*100L + ltime->month)*100L + ltime->day;
327
 
  if (ltime->time_type > type::DRIZZLE_TIMESTAMP_DATE)
 
319
  if (ltime->time_type > DRIZZLE_TIMESTAMP_DATE)
328
320
    date= ((date*100L + ltime->hour)*100L+ ltime->minute)*100L + ltime->second;
329
 
 
330
 
  if (int2_class_decimal(E_DEC_FATAL_ERROR, date, false, dec))
 
321
  if (int2my_decimal(E_DEC_FATAL_ERROR, date, false, dec))
331
322
    return dec;
332
 
 
333
323
  if (ltime->second_part)
334
324
  {
335
325
    dec->buf[(dec->intg-1) / 9 + 1]= ltime->second_part * 1000;
336
326
    dec->frac= 6;
337
327
  }
338
 
 
339
328
  return dec;
340
329
}
341
330
 
342
331
 
343
 
void class_decimal_trim(uint32_t *precision, uint32_t *scale)
 
332
void my_decimal_trim(uint32_t *precision, uint32_t *scale)
344
333
{
345
334
  if (!(*precision) && !(*scale))
346
335
  {
373
362
#define DIG_MASK     100000000
374
363
#define DIG_BASE     1000000000
375
364
#define DIG_MAX      (DIG_BASE-1)
376
 
 
377
 
template<typename T> 
378
 
inline static T round_up(const T &x)
379
 
{
380
 
  return (x+DIG_PER_DEC1-1)/DIG_PER_DEC1;
381
 
}
382
 
 
 
365
#define ROUND_UP(X)  (((X)+DIG_PER_DEC1-1)/DIG_PER_DEC1)
383
366
static const dec1 powers10[DIG_PER_DEC1+1]={
384
367
  1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000};
385
368
static const int dig2bytes[DIG_PER_DEC1+1]={0, 1, 1, 2, 2, 3, 3, 4, 4, 4};
388
371
  999900000, 999990000, 999999000,
389
372
  999999900, 999999990 };
390
373
 
391
 
#ifdef HAVE_VALGRIND
 
374
#ifdef HAVE_purify
392
375
#define sanity(d) assert((d)->len > 0)
393
376
#else
394
377
#define sanity(d) assert((d)->len >0 && ((d)->buf[0] | \
395
378
                              (d)->buf[(d)->len-1] | 1))
396
379
#endif
397
380
 
398
 
inline static void fix_intg_frac_error(const int len, int &intg1, int &frac1, int &error)
399
 
{
400
 
  if (unlikely(intg1+frac1 > len))
401
 
  {
402
 
    if (unlikely(intg1 > len))
403
 
    {
404
 
      intg1=(len);
405
 
      frac1=0;
406
 
      error=E_DEC_OVERFLOW;
407
 
    }
408
 
    else
409
 
    {
410
 
      frac1=(len)-intg1;
411
 
      error=E_DEC_TRUNCATED;
412
 
    }
413
 
  }
414
 
  else
415
 
    error=E_DEC_OK;
416
 
}
417
 
 
418
 
/* assume carry <= 1 */
419
 
inline static void add(dec1 &to, const dec1 &from1, const dec1& from2, dec1 &carry)
420
 
{
421
 
  dec1 a=from1+from2+carry;
422
 
  assert(carry <= 1);
423
 
  if ((carry= (a >= DIG_BASE))) /* no division here! */
424
 
    a-=DIG_BASE;
425
 
  to=a;
426
 
}
427
 
 
428
 
inline static void add2(dec1 &to, const dec1 &from1, const dec1 &from2, dec1 &carry)
429
 
{
430
 
  dec2 a=dec2(from1)+from2+carry;
431
 
  if ((carry= (a >= DIG_BASE)))
432
 
    a-=DIG_BASE;
433
 
  if (unlikely(a >= DIG_BASE))
434
 
  {
435
 
    a-=DIG_BASE;
436
 
    carry++;
437
 
  }
438
 
  to=dec1(a);
439
 
}
440
 
 
441
 
/* to=from1-from2 */
442
 
inline static void sub(dec1 &to, const dec1 &from1, const dec1 &from2, dec1 &carry)
443
 
{
444
 
  dec1 a=from1-from2-carry;
445
 
  if ((carry= (a < 0)))
446
 
    a+=DIG_BASE;
447
 
  to=a;
448
 
}
449
 
 
450
 
/* to=from1-from2 */
451
 
inline static void sub2(dec1 &to, const dec1 &from1, const dec1 &from2, dec1 &carry)
452
 
{
453
 
  dec1 a=from1-from2-carry;
454
 
  if ((carry= (a < 0)))
455
 
    a+=DIG_BASE;
456
 
  if (unlikely(a < 0))
457
 
  {
458
 
    a+=DIG_BASE;
459
 
    carry++;
460
 
  }
461
 
  to=a;
462
 
}
 
381
#define FIX_INTG_FRAC_ERROR(len, intg1, frac1, error)                   \
 
382
        do                                                              \
 
383
        {                                                               \
 
384
          if (unlikely(intg1+frac1 > (len)))                            \
 
385
          {                                                             \
 
386
            if (unlikely(intg1 > (len)))                                \
 
387
            {                                                           \
 
388
              intg1=(len);                                              \
 
389
              frac1=0;                                                  \
 
390
              error=E_DEC_OVERFLOW;                                     \
 
391
            }                                                           \
 
392
            else                                                        \
 
393
            {                                                           \
 
394
              frac1=(len)-intg1;                                        \
 
395
              error=E_DEC_TRUNCATED;                                    \
 
396
            }                                                           \
 
397
          }                                                             \
 
398
          else                                                          \
 
399
            error=E_DEC_OK;                                             \
 
400
        } while(0)
 
401
 
 
402
#define ADD(to, from1, from2, carry)  /* assume carry <= 1 */           \
 
403
        do                                                              \
 
404
        {                                                               \
 
405
          dec1 a=(from1)+(from2)+(carry);                               \
 
406
          assert((carry) <= 1);                                    \
 
407
          if (((carry)= a >= DIG_BASE)) /* no division here! */         \
 
408
            a-=DIG_BASE;                                                \
 
409
          (to)=a;                                                       \
 
410
        } while(0)
 
411
 
 
412
#define ADD2(to, from1, from2, carry)                                   \
 
413
        do                                                              \
 
414
        {                                                               \
 
415
          dec2 a=((dec2)(from1))+(from2)+(carry);                       \
 
416
          if (((carry)= a >= DIG_BASE))                                 \
 
417
            a-=DIG_BASE;                                                \
 
418
          if (unlikely(a >= DIG_BASE))                                  \
 
419
          {                                                             \
 
420
            a-=DIG_BASE;                                                \
 
421
            carry++;                                                    \
 
422
          }                                                             \
 
423
          (to)=(dec1) a;                                                \
 
424
        } while(0)
 
425
 
 
426
#define SUB(to, from1, from2, carry) /* to=from1-from2 */               \
 
427
        do                                                              \
 
428
        {                                                               \
 
429
          dec1 a=(from1)-(from2)-(carry);                               \
 
430
          if (((carry)= a < 0))                                         \
 
431
            a+=DIG_BASE;                                                \
 
432
          (to)=a;                                                       \
 
433
        } while(0)
 
434
 
 
435
#define SUB2(to, from1, from2, carry) /* to=from1-from2 */              \
 
436
        do                                                              \
 
437
        {                                                               \
 
438
          dec1 a=(from1)-(from2)-(carry);                               \
 
439
          if (((carry)= a < 0))                                         \
 
440
            a+=DIG_BASE;                                                \
 
441
          if (unlikely(a < 0))                                          \
 
442
          {                                                             \
 
443
            a+=DIG_BASE;                                                \
 
444
            carry++;                                                    \
 
445
          }                                                             \
 
446
          (to)=a;                                                       \
 
447
        } while(0)
463
448
 
464
449
/**
465
 
  @brief  Get maximum value for given precision and scale
466
 
 
467
 
  @param  precision/scale  see decimal_bin_size() below
468
 
  @param  to              decimal where where the result will be stored
 
450
  Swap the contents of two variables.
 
451
 */
 
452
#define swap_variables(TYPE, a, b) \
 
453
  do {                             \
 
454
    TYPE dummy;                    \
 
455
    dummy= a;                      \
 
456
    a= b;                          \
 
457
    b= dummy;                      \
 
458
  } while (0)
 
459
 
 
460
 
 
461
 
 
462
/*
 
463
  Get maximum value for given precision and scale
 
464
 
 
465
  SYNOPSIS
 
466
    max_decimal()
 
467
    precision/scale - see decimal_bin_size() below
 
468
    to              - decimal where where the result will be stored
469
469
                      to->buf and to->len must be set.
470
470
*/
471
471
 
519
519
}
520
520
 
521
521
 
522
 
/**
523
 
 @brief Count actual length of fraction part (without ending zeroes)
 
522
/*
 
523
  Count actual length of fraction part (without ending zeroes)
524
524
 
525
 
 @param from    number for processing
 
525
  SYNOPSIS
 
526
    decimal_actual_fraction()
 
527
    from    number for processing
526
528
*/
527
529
 
528
530
int decimal_actual_fraction(decimal_t *from)
529
531
{
530
532
  int frac= from->frac, i;
531
 
  dec1 *buf0= from->buf + round_up(from->intg) + round_up(frac) - 1;
 
533
  dec1 *buf0= from->buf + ROUND_UP(from->intg) + ROUND_UP(frac) - 1;
532
534
 
533
535
  if (frac == 0)
534
536
    return 0;
548
550
}
549
551
 
550
552
 
551
 
/**
552
 
 @brief  Convert decimal to its printable string representation
 
553
/*
 
554
  Convert decimal to its printable string representation
553
555
 
554
 
 @param  from       value to convert
555
 
 @param  to         points to buffer where string representation
556
 
                    should be stored
557
 
 @param  to_len     in:  size of to buffer
558
 
                    out: length of the actually written string
559
 
 @param  fixed_precision 0 if representation can be variable length and
 
556
  SYNOPSIS
 
557
    decimal2string()
 
558
      from            - value to convert
 
559
      to              - points to buffer where string representation
 
560
                        should be stored
 
561
      *to_len         - in:  size of to buffer
 
562
                        out: length of the actually written string
 
563
      fixed_precision - 0 if representation can be variable length and
560
564
                        fixed_decimals will not be checked in this case.
561
565
                        Put number as with fixed point position with this
562
566
                        number of digits (sign counted and decimal point is
563
567
                        counted)
564
 
 @param  fixed_decimals  number digits after point.
565
 
 @param  filler          character to fill gaps in case of fixed_precision > 0
 
568
      fixed_decimals  - number digits after point.
 
569
      filler          - character to fill gaps in case of fixed_precision > 0
566
570
 
567
 
 @return error code
568
 
   @retval E_DEC_OK
569
 
   @retval E_DEC_TRUNCATED
570
 
   @retval E_DEC_OVERFLOW
 
571
  RETURN VALUE
 
572
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW
571
573
*/
 
574
 
572
575
int decimal2string(const decimal_t *from, char *to, int *to_len,
573
576
                   int fixed_precision, int fixed_decimals,
574
577
                   char filler)
633
636
  {
634
637
    char *s1= s + intg_len;
635
638
    fill= frac_len - frac;
636
 
    buf=buf0+round_up(intg);
 
639
    buf=buf0+ROUND_UP(intg);
637
640
    *s1++='.';
638
641
    for (; frac>0; frac-=DIG_PER_DEC1)
639
642
    {
658
661
  if (intg)
659
662
  {
660
663
    s+=intg;
661
 
    for (buf=buf0+round_up(intg); intg>0; intg-=DIG_PER_DEC1)
 
664
    for (buf=buf0+ROUND_UP(intg); intg>0; intg-=DIG_PER_DEC1)
662
665
    {
663
666
      dec1 x=*--buf;
664
667
      for (i=min(intg, DIG_PER_DEC1); i; i--)
675
678
}
676
679
 
677
680
 
678
 
/**
679
 
 @brief  Return bounds of decimal digits in the number
 
681
/*
 
682
  Return bounds of decimal digits in the number
680
683
 
681
 
 @param  from  decimal number for processing
682
 
 @param  start_result  index (from 0 ) of first decimal digits will
683
 
                       be written by this address
684
 
 @param  end_result   index of position just after last decimal digit
 
684
  SYNOPSIS
 
685
    digits_bounds()
 
686
      from         - decimal number for processing
 
687
      start_result - index (from 0 ) of first decimal digits will
 
688
                     be written by this address
 
689
      end_result   - index of position just after last decimal digit
685
690
                     be written by this address
686
691
*/
 
692
 
687
693
static void digits_bounds(decimal_t *from, int *start_result, int *end_result)
688
694
{
689
695
  int start, stop, i;
690
696
  dec1 *buf_beg= from->buf;
691
 
  dec1 *end= from->buf + round_up(from->intg) + round_up(from->frac);
 
697
  dec1 *end= from->buf + ROUND_UP(from->intg) + ROUND_UP(from->frac);
692
698
  dec1 *buf_end= end - 1;
693
699
 
694
700
  /* find non-zero digit from number begining */
737
743
}
738
744
 
739
745
 
740
 
/**
741
 
 @param Left shift for alignment of data in buffer
742
 
 
743
 
 @param  dec     pointer to decimal number which have to be shifted
744
 
 @param  shift   number of decimal digits on which it should be shifted
745
 
 @param  beg     beginning of decimal digits (see digits_bounds())
746
 
 @param  end     end of decimal digits (see digits_bounds())
747
 
 
748
 
 @note
749
 
   Result fitting in the buffer should be garanted.
750
 
   'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive)
751
 
   
752
 
 @todo  Above note is unclear - is 'garanted' a typo for 'guaranteed'
753
 
 or 'granted'?
 
746
/*
 
747
  Left shift for alignment of data in buffer
 
748
 
 
749
  SYNOPSIS
 
750
    do_mini_left_shift()
 
751
    dec     pointer to decimal number which have to be shifted
 
752
    shift   number of decimal digits on which it should be shifted
 
753
    beg/end bounds of decimal digits (see digits_bounds())
 
754
 
 
755
  NOTE
 
756
    Result fitting in the buffer should be garanted.
 
757
    'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive)
754
758
*/
 
759
 
755
760
static void do_mini_left_shift(decimal_t *dec, int shift, int beg, int last)
756
761
{
757
 
  dec1 *from= dec->buf + round_up(beg + 1) - 1;
758
 
  dec1 *end= dec->buf + round_up(last) - 1;
 
762
  dec1 *from= dec->buf + ROUND_UP(beg + 1) - 1;
 
763
  dec1 *end= dec->buf + ROUND_UP(last) - 1;
759
764
  int c_shift= DIG_PER_DEC1 - shift;
760
765
  assert(from >= dec->buf);
761
766
  assert(end < dec->buf + dec->len);
768
773
}
769
774
 
770
775
 
771
 
/**
772
 
  @brief Right shift for alignment of data in buffer
773
 
 
774
 
  @param  dec     pointer to decimal number which have to be shifted
775
 
  @param  shift   number of decimal digits on which it should be shifted
776
 
  @param  beg     beginning of decimal digits (see digits_bounds())
777
 
  @param  end     end of decimal digits (see digits_bounds())
778
 
 
779
 
  @note
 
776
/*
 
777
  Right shift for alignment of data in buffer
 
778
 
 
779
  SYNOPSIS
 
780
    do_mini_left_shift()
 
781
    dec     pointer to decimal number which have to be shifted
 
782
    shift   number of decimal digits on which it should be shifted
 
783
    beg/end bounds of decimal digits (see digits_bounds())
 
784
 
 
785
  NOTE
780
786
    Result fitting in the buffer should be garanted.
781
787
    'shift' have to be from 1 to DIG_PER_DEC1-1 (inclusive)
782
788
*/
 
789
 
783
790
static void do_mini_right_shift(decimal_t *dec, int shift, int beg, int last)
784
791
{
785
 
  dec1 *from= dec->buf + round_up(last) - 1;
786
 
  dec1 *end= dec->buf + round_up(beg + 1) - 1;
 
792
  dec1 *from= dec->buf + ROUND_UP(last) - 1;
 
793
  dec1 *end= dec->buf + ROUND_UP(beg + 1) - 1;
787
794
  int c_shift= DIG_PER_DEC1 - shift;
788
795
  assert(from < dec->buf + dec->len);
789
796
  assert(end >= dec->buf);
796
803
}
797
804
 
798
805
 
799
 
/**
800
 
  @brief  Shift of decimal digits in given number (with rounding if it need)
 
806
/*
 
807
  Shift of decimal digits in given number (with rounding if it need)
801
808
 
802
 
  @param  dec       number to be shifted
803
 
  @param  shift     number of decimal positions
 
809
  SYNOPSIS
 
810
    decimal_shift()
 
811
    dec       number to be shifted
 
812
    shift     number of decimal positions
804
813
              shift > 0 means shift to left shift
805
814
              shift < 0 meand right shift
806
 
 
807
 
  @note
 
815
  NOTE
808
816
    In fact it is multipling on 10^shift.
 
817
  RETURN
 
818
    E_DEC_OK          OK
 
819
    E_DEC_OVERFLOW    operation lead to overflow, number is untoched
 
820
    E_DEC_TRUNCATED   number was rounded to fit into buffer
 
821
*/
809
822
 
810
 
  @return  Error code
811
 
   @retval E_DEC_OK          OK
812
 
   @retval E_DEC_OVERFLOW    operation lead to overflow, number is untoched
813
 
   @retval E_DEC_TRUNCATED   number was rounded to fit into buffer
814
 
*/
815
823
static int decimal_shift(decimal_t *dec, int shift)
816
824
{
817
825
  /* index of first non zero digit (all indexes from 0) */
819
827
  /* index of position after last decimal digit */
820
828
  int end;
821
829
  /* index of digit position just after point */
822
 
  int point= round_up(dec->intg) * DIG_PER_DEC1;
 
830
  int point= ROUND_UP(dec->intg) * DIG_PER_DEC1;
823
831
  /* new point position */
824
832
  int new_point= point + shift;
825
833
  /* number of digits in result */
837
845
 
838
846
  if (beg == end)
839
847
  {
840
 
    dec->set_zero();
 
848
    decimal_make_zero(dec);
841
849
    return E_DEC_OK;
842
850
  }
843
851
 
846
854
  digits_frac= end - new_point;
847
855
  set_if_bigger(digits_frac, 0);
848
856
 
849
 
  if ((new_len= round_up(digits_int) + (new_frac_len= round_up(digits_frac))) >
 
857
  if ((new_len= ROUND_UP(digits_int) + (new_frac_len= ROUND_UP(digits_frac))) >
850
858
      dec->len)
851
859
  {
852
860
    int lack= new_len - dec->len;
870
878
        we lost all digits (they will be shifted out of buffer), so we can
871
879
        just return 0
872
880
      */
873
 
      dec->set_zero();
874
 
 
 
881
      decimal_make_zero(dec);
875
882
      return E_DEC_TRUNCATED;
876
883
    }
877
884
  }
907
914
    if (do_left)
908
915
    {
909
916
      do_mini_left_shift(dec, l_mini_shift, beg, end);
910
 
      mini_shift= (-l_mini_shift);
 
917
      mini_shift=- l_mini_shift;
911
918
    }
912
919
    else
913
920
    {
940
947
    {
941
948
      /* move left */
942
949
      d_shift= new_front / DIG_PER_DEC1;
943
 
      to= dec->buf + (round_up(beg + 1) - 1 - d_shift);
944
 
      barier= dec->buf + (round_up(end) - 1 - d_shift);
 
950
      to= dec->buf + (ROUND_UP(beg + 1) - 1 - d_shift);
 
951
      barier= dec->buf + (ROUND_UP(end) - 1 - d_shift);
945
952
      assert(to >= dec->buf);
946
953
      assert(barier + d_shift < dec->buf + dec->len);
947
954
      for(; to <= barier; to++)
954
961
    {
955
962
      /* move right */
956
963
      d_shift= (1 - new_front) / DIG_PER_DEC1;
957
 
      to= dec->buf + round_up(end) - 1 + d_shift;
958
 
      barier= dec->buf + round_up(beg + 1) - 1 + d_shift;
 
964
      to= dec->buf + ROUND_UP(end) - 1 + d_shift;
 
965
      barier= dec->buf + ROUND_UP(beg + 1) - 1 + d_shift;
959
966
      assert(to < dec->buf + dec->len);
960
967
      assert(barier - d_shift >= dec->buf);
961
968
      for(; to >= barier; to--)
974
981
 
975
982
    Only one of following 'for' loops will work becouse beg <= end
976
983
  */
977
 
  beg= round_up(beg + 1) - 1;
978
 
  end= round_up(end) - 1;
 
984
  beg= ROUND_UP(beg + 1) - 1;
 
985
  end= ROUND_UP(end) - 1;
979
986
  assert(new_point >= 0);
980
987
 
981
988
  /* We don't want negative new_point below */
982
989
  if (new_point != 0)
983
 
    new_point= round_up(new_point) - 1;
 
990
    new_point= ROUND_UP(new_point) - 1;
984
991
 
985
992
  if (new_point > end)
986
993
  {
1000
1007
}
1001
1008
 
1002
1009
 
1003
 
/**
1004
 
  @brief  Convert string to decimal
 
1010
/*
 
1011
  Convert string to decimal
1005
1012
 
1006
 
  @param  from    value to convert. Doesn't have to be \0 terminated!
1007
 
  @param  to      decimal where where the result will be stored
 
1013
  SYNOPSIS
 
1014
    internal_str2decl()
 
1015
      from    - value to convert. Doesn't have to be \0 terminated!
 
1016
      to      - decimal where where the result will be stored
1008
1017
                to->buf and to->len must be set.
1009
 
  @param  end     Pointer to pointer to end of string. Will on return be
 
1018
      end     - Pointer to pointer to end of string. Will on return be
1010
1019
                set to the char after the last used character
1011
 
  @param  fixed   use to->intg, to->frac as limits for input number
 
1020
      fixed   - use to->intg, to->frac as limits for input number
1012
1021
 
1013
 
  @note
 
1022
  NOTE
1014
1023
    to->intg and to->frac can be modified even when fixed=1
1015
1024
    (but only decreased, in this case)
1016
1025
 
1017
 
  @return
 
1026
  RETURN VALUE
1018
1027
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_BAD_NUM/E_DEC_OOM
1019
1028
    In case of E_DEC_FATAL_ERROR *to is set to decimal zero
1020
1029
    (to make error handling easier)
1021
1030
*/
 
1031
 
1022
1032
int
1023
1033
internal_str2dec(char *from, decimal_t *to, char **end, bool fixed)
1024
1034
{
1075
1085
      error=E_DEC_OVERFLOW;
1076
1086
      intg=to->intg;
1077
1087
    }
1078
 
    intg1=round_up(intg);
1079
 
    frac1=round_up(frac);
 
1088
    intg1=ROUND_UP(intg);
 
1089
    frac1=ROUND_UP(frac);
1080
1090
    if (intg1+frac1 > to->len)
1081
1091
    {
1082
1092
      error= E_DEC_OOM;
1085
1095
  }
1086
1096
  else
1087
1097
  {
1088
 
    intg1=round_up(intg);
1089
 
    frac1=round_up(frac);
1090
 
    fix_intg_frac_error(to->len, intg1, frac1, error);
 
1098
    intg1=ROUND_UP(intg);
 
1099
    frac1=ROUND_UP(frac);
 
1100
    FIX_INTG_FRAC_ERROR(to->len, intg1, frac1, error);
1091
1101
    if (unlikely(error))
1092
1102
    {
1093
1103
      frac=frac1*DIG_PER_DEC1;
1163
1173
  return error;
1164
1174
 
1165
1175
fatal_error:
1166
 
  to->set_zero();
 
1176
  decimal_make_zero(to);
1167
1177
  return error;
1168
1178
}
1169
1179
 
1170
1180
 
1171
 
/**
1172
 
  @param Convert decimal to double
1173
 
 
1174
 
  @param[in]   from   value to convert
1175
 
  @param[out]  to     result will be stored there
1176
 
 
1177
 
  @return
 
1181
/*
 
1182
  Convert decimal to double
 
1183
 
 
1184
  SYNOPSIS
 
1185
    decimal2double()
 
1186
      from    - value to convert
 
1187
      to      - result will be stored there
 
1188
 
 
1189
  RETURN VALUE
1178
1190
    E_DEC_OK/E_DEC_OVERFLOW/E_DEC_TRUNCATED
1179
1191
*/
1180
1192
 
1192
1204
  return (rc != E_DEC_OK) ? rc : (error ? E_DEC_OVERFLOW : E_DEC_OK);
1193
1205
}
1194
1206
 
1195
 
/**
1196
 
 @param  Convert double to decimal
1197
 
 
1198
 
 @param[in]  from    value to convert
1199
 
 @param[out] to      result will be stored there
1200
 
 
1201
 
 @return
 
1207
/*
 
1208
  Convert double to decimal
 
1209
 
 
1210
  SYNOPSIS
 
1211
    double2decimal()
 
1212
      from    - value to convert
 
1213
      to      - result will be stored there
 
1214
 
 
1215
  RETURN VALUE
1202
1216
    E_DEC_OK/E_DEC_OVERFLOW/E_DEC_TRUNCATED
1203
1217
*/
1204
1218
 
1322
1336
  return E_DEC_OK;
1323
1337
}
1324
1338
 
1325
 
/**
1326
 
 @brief
1327
 
  Convert decimal to its binary fixed-length representation (suitable for
1328
 
  comparing with memcmp)
1329
 
 
 
1339
/*
 
1340
  Convert decimal to its binary fixed-length representation
 
1341
  two representations of the same length can be compared with memcmp
 
1342
  with the correct -1/0/+1 result
 
1343
 
 
1344
  SYNOPSIS
 
1345
    decimal2bin()
 
1346
      from    - value to convert
 
1347
      to      - points to buffer where string representation should be stored
 
1348
      precision/scale - see decimal_bin_size() below
 
1349
 
 
1350
  NOTE
 
1351
    the buffer is assumed to be of the size decimal_bin_size(precision, scale)
 
1352
 
 
1353
  RETURN VALUE
 
1354
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW
 
1355
 
 
1356
  DESCRIPTION
1330
1357
    for storage decimal numbers are converted to the "binary" format.
1331
1358
 
1332
1359
    This format has the following properties:
1387
1414
    And for -1234567890.1234 it would be
1388
1415
 
1389
1416
                7E F2 04 37 2D FB 2D
1390
 
 
1391
 
 
1392
 
  @param from      value to convert
1393
 
  @param to        points to buffer where string representation should be stored
1394
 
  @param precision see decimal_bin_size() below
1395
 
  @param frac      see decimal_bin_size() below
1396
 
 
1397
 
  @note
1398
 
    The buffer is assumed to be of the size decimal_bin_size(precision, scale)
1399
 
 
1400
 
  @return
1401
 
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW
1402
 
 
1403
1417
*/
1404
1418
int decimal2bin(const decimal_t *from, unsigned char *to, int precision, int frac)
1405
1419
{
1519
1533
  return error;
1520
1534
}
1521
1535
 
1522
 
/**
1523
 
 @brief Restores decimal from its binary fixed-length representation
1524
 
 
1525
 
 @param  from    value to convert
1526
 
 @param  to      result
1527
 
 @param  precision see decimal_bin_size() below
1528
 
 @param  scale     see decimal_bin_size() below
1529
 
 
1530
 
 @note
 
1536
/*
 
1537
  Restores decimal from its binary fixed-length representation
 
1538
 
 
1539
  SYNOPSIS
 
1540
    bin2decimal()
 
1541
      from    - value to convert
 
1542
      to      - result
 
1543
      precision/scale - see decimal_bin_size() below
 
1544
 
 
1545
  NOTE
1531
1546
    see decimal2bin()
1532
1547
    the buffer is assumed to be of the size decimal_bin_size(precision, scale)
1533
1548
 
1534
 
 @return
 
1549
  RETURN VALUE
1535
1550
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW
1536
1551
*/
 
1552
 
1537
1553
int bin2decimal(const unsigned char *from, decimal_t *to, int precision, int scale)
1538
1554
{
1539
1555
  int error=E_DEC_OK, intg=precision-scale,
1551
1567
  d_copy[0]^= 0x80;
1552
1568
  from= d_copy;
1553
1569
 
1554
 
  fix_intg_frac_error(to->len, intg1, frac1, error);
 
1570
  FIX_INTG_FRAC_ERROR(to->len, intg1, frac1, error);
1555
1571
  if (unlikely(error))
1556
1572
  {
1557
1573
    if (intg1 < intg0+(intg0x>0))
1632
1648
  return error;
1633
1649
 
1634
1650
err:
1635
 
  to->set_zero();
 
1651
  decimal_make_zero(((decimal_t*) to));
1636
1652
  return(E_DEC_BAD_NUM);
1637
1653
}
1638
1654
 
1639
 
/**
1640
 
 @brief  Returns the size of array to hold a binary representation of a decimal
 
1655
/*
 
1656
  Returns the size of array to hold a binary representation of a decimal
1641
1657
 
1642
 
 @return  Size in bytes
 
1658
  RETURN VALUE
 
1659
    size in bytes
1643
1660
*/
 
1661
 
1644
1662
int decimal_bin_size(int precision, int scale)
1645
1663
{
1646
1664
  int intg=precision-scale,
1652
1670
         frac0*sizeof(dec1)+dig2bytes[frac0x];
1653
1671
}
1654
1672
 
1655
 
/**
1656
 
 @brief  Rounds the decimal to "scale" digits
1657
 
 
1658
 
 @param from    - decimal to round,
1659
 
 @param to      - result buffer. from==to is allowed
1660
 
 @param scale   - to what position to round. can be negative!
1661
 
 @param mode    - round to nearest even or truncate
1662
 
 
1663
 
 @note
 
1673
/*
 
1674
  Rounds the decimal to "scale" digits
 
1675
 
 
1676
  SYNOPSIS
 
1677
    decimal_round()
 
1678
      from    - decimal to round,
 
1679
      to      - result buffer. from==to is allowed
 
1680
      scale   - to what position to round. can be negative!
 
1681
      mode    - round to nearest even or truncate
 
1682
 
 
1683
  NOTES
1664
1684
    scale can be negative !
1665
1685
    one TRUNCATED error (line XXX below) isn't treated very logical :(
1666
1686
 
1667
 
 @return
 
1687
  RETURN VALUE
1668
1688
    E_DEC_OK/E_DEC_TRUNCATED
1669
1689
*/
 
1690
 
1670
1691
int
1671
1692
decimal_round(const decimal_t *from, decimal_t *to, int scale,
1672
1693
              decimal_round_mode mode)
1673
1694
{
1674
 
  int frac0=scale>0 ? round_up(scale) : scale/DIG_PER_DEC1,
1675
 
      frac1=round_up(from->frac), round_digit= 0,
1676
 
      intg0=round_up(from->intg), error=E_DEC_OK, len=to->len,
1677
 
      intg1=round_up(from->intg +
 
1695
  int frac0=scale>0 ? ROUND_UP(scale) : scale/DIG_PER_DEC1,
 
1696
      frac1=ROUND_UP(from->frac), round_digit= 0,
 
1697
      intg0=ROUND_UP(from->intg), error=E_DEC_OK, len=to->len,
 
1698
      intg1=ROUND_UP(from->intg +
1678
1699
                     (((intg0 + frac0)>0) && (from->buf[0] == DIG_MAX)));
1679
1700
  dec1 *buf0=from->buf, *buf1=to->buf, x, y, carry=0;
1680
1701
  int first_dig;
1699
1720
 
1700
1721
  if (scale+from->intg < 0)
1701
1722
  {
1702
 
    to->set_zero();
 
1723
    decimal_make_zero(to);
1703
1724
    return E_DEC_OK;
1704
1725
  }
1705
1726
 
1770
1791
    }
1771
1792
    else if (frac0+intg0==0)
1772
1793
    {
1773
 
      to->set_zero();
 
1794
      decimal_make_zero(to);
1774
1795
      return E_DEC_OK;
1775
1796
    }
1776
1797
  }
1777
1798
  else
1778
1799
  {
1779
 
  /** @todo fix this code as it won't work for CEILING mode */
 
1800
    /* TODO - fix this code as it won't work for CEILING mode */
1780
1801
    int pos=frac0*DIG_PER_DEC1-scale-1;
1781
1802
    assert(frac0+intg0 > 0);
1782
1803
    x=*buf1 / powers10[pos];
1809
1830
    carry=1;
1810
1831
    *buf1-=DIG_BASE;
1811
1832
    while (carry && --buf1 >= to->buf)
1812
 
      add(*buf1, *buf1, 0, carry);
 
1833
      ADD(*buf1, *buf1, 0, carry);
1813
1834
    if (unlikely(carry))
1814
1835
    {
1815
1836
      /* shifting the number to create space for new digit */
1862
1883
 
1863
1884
static int do_add(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
1864
1885
{
1865
 
  int intg1=round_up(from1->intg), intg2=round_up(from2->intg),
1866
 
      frac1=round_up(from1->frac), frac2=round_up(from2->frac),
 
1886
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
 
1887
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac),
1867
1888
      frac0=max(frac1, frac2), intg0=max(intg1, intg2), error;
1868
1889
  dec1 *buf1, *buf2, *buf0, *stop, *stop2, x, carry;
1869
1890
 
1879
1900
    to->buf[0]=0; /* safety */
1880
1901
  }
1881
1902
 
1882
 
  fix_intg_frac_error(to->len, intg0, frac0, error);
 
1903
  FIX_INTG_FRAC_ERROR(to->len, intg0, frac0, error);
1883
1904
  if (unlikely(error == E_DEC_OVERFLOW))
1884
1905
  {
1885
1906
    max_decimal(to->len * DIG_PER_DEC1, 0, to);
1922
1943
  carry=0;
1923
1944
  while (buf1 > stop2)
1924
1945
  {
1925
 
    add(*--buf0, *--buf1, *--buf2, carry);
 
1946
    ADD(*--buf0, *--buf1, *--buf2, carry);
1926
1947
  }
1927
1948
 
1928
1949
  /* part 3 - cmin(intg) ... cmax(intg) */
1930
1951
                        ((stop=from2->buf)+intg2-intg1) ;
1931
1952
  while (buf1 > stop)
1932
1953
  {
1933
 
    add(*--buf0, *--buf1, 0, carry);
 
1954
    ADD(*--buf0, *--buf1, 0, carry);
1934
1955
  }
1935
1956
 
1936
1957
  if (unlikely(carry))
1944
1965
   if to==0, return -1/0/+1 - the result of the comparison */
1945
1966
static int do_sub(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
1946
1967
{
1947
 
  int intg1=round_up(from1->intg), intg2=round_up(from2->intg),
1948
 
      frac1=round_up(from1->frac), frac2=round_up(from2->frac);
 
1968
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
 
1969
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac);
1949
1970
  int frac0=max(frac1, frac2), error;
1950
1971
  dec1 *buf1, *buf2, *buf0, *stop1, *stop2, *start1, *start2, carry=0;
1951
1972
 
1995
2016
      {
1996
2017
        if (to == 0) /* decimal_cmp() */
1997
2018
          return 0;
1998
 
 
1999
 
        to->set_zero();
2000
 
 
 
2019
        decimal_make_zero(to);
2001
2020
        return E_DEC_OK;
2002
2021
      }
2003
2022
    }
2013
2032
  /* ensure that always from1 > from2 (and intg1 >= intg2) */
2014
2033
  if (carry)
2015
2034
  {
2016
 
    swap(from1, from2);
2017
 
    swap(start1, start2);
2018
 
    swap(intg1, intg2);
2019
 
    swap(frac1, frac2);
 
2035
    swap_variables(const decimal_t *,from1, from2);
 
2036
    swap_variables(dec1 *,start1, start2);
 
2037
    swap_variables(int,intg1,intg2);
 
2038
    swap_variables(int,frac1,frac2);
2020
2039
    to->sign= 1 - to->sign;
2021
2040
  }
2022
2041
 
2023
 
  fix_intg_frac_error(to->len, intg1, frac0, error);
 
2042
  FIX_INTG_FRAC_ERROR(to->len, intg1, frac0, error);
2024
2043
  buf0=to->buf+intg1+frac0;
2025
2044
 
2026
2045
  to->frac=max(from1->frac, from2->frac);
2054
2073
      *--buf0=0;
2055
2074
    while (buf2 > stop2)
2056
2075
    {
2057
 
      sub(*--buf0, 0, *--buf2, carry);
 
2076
      SUB(*--buf0, 0, *--buf2, carry);
2058
2077
    }
2059
2078
  }
2060
2079
 
2061
2080
  /* part 2 - cmin(frac) ... intg2 */
2062
2081
  while (buf2 > start2)
2063
2082
  {
2064
 
    sub(*--buf0, *--buf1, *--buf2, carry);
 
2083
    SUB(*--buf0, *--buf1, *--buf2, carry);
2065
2084
  }
2066
2085
 
2067
2086
  /* part 3 - intg2 ... intg1 */
2068
2087
  while (carry && buf1 > start1)
2069
2088
  {
2070
 
    sub(*--buf0, *--buf1, 0, carry);
 
2089
    SUB(*--buf0, *--buf1, 0, carry);
2071
2090
  }
2072
2091
 
2073
2092
  while (buf1 > start1)
2108
2127
  return from1->sign > from2->sign ? -1 : 1;
2109
2128
}
2110
2129
 
2111
 
int decimal_t::isZero() const
 
2130
int decimal_is_zero(const decimal_t *from)
2112
2131
{
2113
 
  dec1 *buf1= buf,
2114
 
       *end= buf1 +round_up(intg) +round_up(frac);
2115
 
 
 
2132
  dec1 *buf1=from->buf,
 
2133
       *end=buf1+ROUND_UP(from->intg)+ROUND_UP(from->frac);
2116
2134
  while (buf1 < end)
2117
 
  {
2118
2135
    if (*buf1++)
2119
 
    {
2120
2136
      return 0;
2121
 
    }
2122
 
  }
2123
 
 
2124
2137
  return 1;
2125
2138
}
2126
2139
 
2127
 
/**
2128
 
 @brief multiply two decimals
2129
 
 
2130
 
 @param[in]   from1  First factor
2131
 
 @param[in]   from2  Second factor
2132
 
 @param[out]  to     product
2133
 
 
2134
 
 @return
 
2140
/*
 
2141
  multiply two decimals
 
2142
 
 
2143
  SYNOPSIS
 
2144
    decimal_mul()
 
2145
      from1, from2 - factors
 
2146
      to      - product
 
2147
 
 
2148
  RETURN VALUE
2135
2149
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW;
2136
2150
 
2137
 
 @note
 
2151
  NOTES
2138
2152
    in this implementation, with sizeof(dec1)=4 we have DIG_PER_DEC1=9,
2139
2153
    and 63-digit number will take only 7 dec1 words (basically a 7-digit
2140
2154
    "base 999999999" number).  Thus there's no need in fast multiplication
2146
2160
*/
2147
2161
int decimal_mul(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
2148
2162
{
2149
 
  int intg1=round_up(from1->intg), intg2=round_up(from2->intg),
2150
 
      frac1=round_up(from1->frac), frac2=round_up(from2->frac),
2151
 
      intg0=round_up(from1->intg+from2->intg),
 
2163
  int intg1=ROUND_UP(from1->intg), intg2=ROUND_UP(from2->intg),
 
2164
      frac1=ROUND_UP(from1->frac), frac2=ROUND_UP(from2->frac),
 
2165
      intg0=ROUND_UP(from1->intg+from2->intg),
2152
2166
      frac0=frac1+frac2, error, i, j, d_to_move;
2153
2167
  dec1 *buf1=from1->buf+intg1, *buf2=from2->buf+intg2, *buf0,
2154
2168
       *start2, *stop2, *stop1, *start0, carry;
2157
2171
 
2158
2172
  i=intg0;
2159
2173
  j=frac0;
2160
 
  fix_intg_frac_error(to->len, intg0, frac0, error);
 
2174
  FIX_INTG_FRAC_ERROR(to->len, intg0, frac0, error);
2161
2175
  to->sign=from1->sign != from2->sign;
2162
2176
  to->frac=from1->frac+from2->frac;
2163
2177
  to->intg=intg0*DIG_PER_DEC1;
2198
2212
      dec2 p= ((dec2)*buf1) * ((dec2)*buf2);
2199
2213
      hi=(dec1)(p/DIG_BASE);
2200
2214
      lo=(dec1)(p-((dec2)hi)*DIG_BASE);
2201
 
      add2(*buf0, *buf0, lo, carry);
 
2215
      ADD2(*buf0, *buf0, lo, carry);
2202
2216
      carry+=hi;
2203
2217
    }
2204
2218
    if (carry)
2205
2219
    {
2206
2220
      if (buf0 < to->buf)
2207
2221
        return E_DEC_OVERFLOW;
2208
 
      add2(*buf0, *buf0, 0, carry);
 
2222
      ADD2(*buf0, *buf0, 0, carry);
2209
2223
    }
2210
2224
    for (buf0--; carry; buf0--)
2211
2225
    {
2212
2226
      if (buf0 < to->buf)
2213
2227
        return E_DEC_OVERFLOW;
2214
 
      add(*buf0, *buf0, 0, carry);
 
2228
      ADD(*buf0, *buf0, 0, carry);
2215
2229
    }
2216
2230
  }
2217
2231
 
2228
2242
      if (++buf == end)
2229
2243
      {
2230
2244
        /* We got decimal zero */
2231
 
        to->set_zero();
 
2245
        decimal_make_zero(to);
2232
2246
        break;
2233
2247
      }
2234
2248
    }
2235
2249
  }
2236
2250
  buf1= to->buf;
2237
 
  d_to_move= intg0 + round_up(to->frac);
 
2251
  d_to_move= intg0 + ROUND_UP(to->frac);
2238
2252
  while (!*buf1 && (to->intg > DIG_PER_DEC1))
2239
2253
  {
2240
2254
    buf1++;
2250
2264
  return error;
2251
2265
}
2252
2266
 
2253
 
/**
 
2267
/*
2254
2268
  naive division algorithm (Knuth's Algorithm D in 4.3.1) -
2255
2269
  it's ok for short numbers
2256
2270
  also we're using alloca() to allocate a temporary buffer
2257
2271
 
2258
 
  @todo
2259
 
  If this library is to be used with huge numbers of thousands of
 
2272
  XXX if this library is to be used with huge numbers of thousands of
2260
2273
  digits, fast division must be implemented and alloca should be
2261
2274
  changed to malloc (or at least fallback to malloc if alloca() fails)
2262
2275
  but then, decimal_mul() should be rewritten too :(
2264
2277
static int do_div_mod(const decimal_t *from1, const decimal_t *from2,
2265
2278
                       decimal_t *to, decimal_t *mod, int scale_incr)
2266
2279
{
2267
 
  int frac1=round_up(from1->frac)*DIG_PER_DEC1, prec1=from1->intg+frac1,
2268
 
      frac2=round_up(from2->frac)*DIG_PER_DEC1, prec2=from2->intg+frac2,
 
2280
  int frac1=ROUND_UP(from1->frac)*DIG_PER_DEC1, prec1=from1->intg+frac1,
 
2281
      frac2=ROUND_UP(from2->frac)*DIG_PER_DEC1, prec2=from2->intg+frac2,
2269
2282
      error= 0, i, intg0, frac0, len1, len2, dintg, div_mod=(!mod);
2270
2283
  dec1 *buf0, *buf1=from1->buf, *buf2=from2->buf, *tmp1,
2271
2284
       *start2, *stop2, *stop1, *stop0, norm2, carry, *start1, dcarry;
2298
2311
  }
2299
2312
  if (prec1 <= 0)
2300
2313
  { /* short-circuit everything: from1 == 0 */
2301
 
    to->set_zero();
 
2314
    decimal_make_zero(to);
2302
2315
    return E_DEC_OK;
2303
2316
  }
2304
2317
  for (i=(prec1-1) % DIG_PER_DEC1; *buf1 < powers10[i--]; prec1--) ;
2315
2328
    intg0=0;
2316
2329
  }
2317
2330
  else
2318
 
    intg0=round_up(dintg);
 
2331
    intg0=ROUND_UP(dintg);
2319
2332
  if (mod)
2320
2333
  {
2321
2334
    /* we're calculating N1 % N2.
2334
2347
      N2 is in the buf2, has prec2 digits. Scales are frac1 and
2335
2348
      frac2 accordingly.
2336
2349
      Thus, the result will have
2337
 
         frac = round_up(frac1+frac2+scale_incr)
 
2350
         frac = ROUND_UP(frac1+frac2+scale_incr)
2338
2351
      and
2339
2352
         intg = (prec1-frac1) - (prec2-frac2) + 1
2340
2353
         prec = intg+frac
2341
2354
    */
2342
 
    frac0=round_up(frac1+frac2+scale_incr);
2343
 
    fix_intg_frac_error(to->len, intg0, frac0, error);
 
2355
    frac0=ROUND_UP(frac1+frac2+scale_incr);
 
2356
    FIX_INTG_FRAC_ERROR(to->len, intg0, frac0, error);
2344
2357
    to->sign=from1->sign != from2->sign;
2345
2358
    to->intg=intg0*DIG_PER_DEC1;
2346
2359
    to->frac=frac0*DIG_PER_DEC1;
2351
2364
    while (dintg++ < 0)
2352
2365
      *buf0++=0;
2353
2366
 
2354
 
  len1=(i=round_up(prec1))+round_up(2*frac2+scale_incr+1) + 1;
 
2367
  len1=(i=ROUND_UP(prec1))+ROUND_UP(2*frac2+scale_incr+1) + 1;
2355
2368
  set_if_bigger(len1, 3);
2356
2369
  if (!(tmp1=(dec1 *)alloca(len1*sizeof(dec1))))
2357
2370
    return E_DEC_OOM;
2361
2374
  start1=tmp1;
2362
2375
  stop1=start1+len1;
2363
2376
  start2=buf2;
2364
 
  stop2=buf2+round_up(prec2)-1;
 
2377
  stop2=buf2+ROUND_UP(prec2)-1;
2365
2378
 
2366
2379
  /* removing end zeroes */
2367
2380
  while (*stop2 == 0 && stop2 >= start2)
2420
2433
        x=guess * (*--buf2);
2421
2434
        hi=(dec1)(x/DIG_BASE);
2422
2435
        lo=(dec1)(x-((dec2)hi)*DIG_BASE);
2423
 
        sub2(*buf1, *buf1, lo, carry);
 
2436
        SUB2(*buf1, *buf1, lo, carry);
2424
2437
        carry+=hi;
2425
2438
      }
2426
2439
      carry= dcarry < carry;
2434
2447
        buf1=start1+len2;
2435
2448
        for (carry=0; buf2 > start2; buf1--)
2436
2449
        {
2437
 
          add(*buf1, *buf1, *--buf2, carry);
 
2450
          ADD(*buf1, *buf1, *--buf2, carry);
2438
2451
        }
2439
2452
      }
2440
2453
    }
2453
2466
    if (dcarry)
2454
2467
      *--start1=dcarry;
2455
2468
    buf0=to->buf;
2456
 
    intg0=(int) (round_up(prec1-frac1)-(start1-tmp1));
2457
 
    frac0=round_up(to->frac);
 
2469
    intg0=(int) (ROUND_UP(prec1-frac1)-(start1-tmp1));
 
2470
    frac0=ROUND_UP(to->frac);
2458
2471
    error=E_DEC_OK;
2459
2472
    if (unlikely(frac0==0 && intg0==0))
2460
2473
    {
2461
 
      to->set_zero();
 
2474
      decimal_make_zero(to);
2462
2475
      goto done;
2463
2476
    }
2464
2477
    if (intg0<=0)
2465
2478
    {
2466
2479
      if (unlikely(-intg0 >= to->len))
2467
2480
      {
2468
 
        to->set_zero();
 
2481
        decimal_make_zero(to);
2469
2482
        error=E_DEC_TRUNCATED;
2470
2483
        goto done;
2471
2484
      }
2484
2497
        error=E_DEC_OVERFLOW;
2485
2498
        goto done;
2486
2499
      }
2487
 
      assert(intg0 <= round_up(from2->intg));
 
2500
      assert(intg0 <= ROUND_UP(from2->intg));
2488
2501
      stop1=start1+frac0+intg0;
2489
2502
      to->intg=min(intg0*DIG_PER_DEC1, from2->intg);
2490
2503
    }
2503
2516
  return error;
2504
2517
}
2505
2518
 
2506
 
/**
2507
 
 @brief  division of two decimals
2508
 
 
2509
 
 @param[in]  from1   dividend
2510
 
 @param[in]  from2   divisor
2511
 
 @param[out] to      quotient
2512
 
 
2513
 
 @return
 
2519
/*
 
2520
  division of two decimals
 
2521
 
 
2522
  SYNOPSIS
 
2523
    decimal_div()
 
2524
      from1   - dividend
 
2525
      from2   - divisor
 
2526
      to      - quotient
 
2527
 
 
2528
  RETURN VALUE
2514
2529
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_DIV_ZERO;
2515
2530
 
2516
 
 @note
 
2531
  NOTES
2517
2532
    see do_div_mod()
2518
2533
*/
 
2534
 
2519
2535
int
2520
2536
decimal_div(const decimal_t *from1, const decimal_t *from2, decimal_t *to, int scale_incr)
2521
2537
{
2522
2538
  return do_div_mod(from1, from2, to, 0, scale_incr);
2523
2539
}
2524
2540
 
2525
 
/**
2526
 
 @brief modulus
2527
 
 
2528
 
 the modulus R in    R = M mod N
2529
 
 
2530
 
 is defined as
2531
 
 
2532
 
 0 <= |R| < |M|
2533
 
 sign R == sign M
2534
 
 R = M - k*N, where k is integer
2535
 
 
2536
 
 thus, there's no requirement for M or N to be integers
2537
 
 
2538
 
 
2539
 
 @param from1   dividend
2540
 
 @param from2   divisor
2541
 
 @param to      modulus
2542
 
 
2543
 
 @return
 
2541
/*
 
2542
  modulus
 
2543
 
 
2544
  SYNOPSIS
 
2545
    decimal_mod()
 
2546
      from1   - dividend
 
2547
      from2   - divisor
 
2548
      to      - modulus
 
2549
 
 
2550
  RETURN VALUE
2544
2551
    E_DEC_OK/E_DEC_TRUNCATED/E_DEC_OVERFLOW/E_DEC_DIV_ZERO;
2545
2552
 
2546
 
 @note
 
2553
  NOTES
2547
2554
    see do_div_mod()
2548
2555
 
 
2556
  DESCRIPTION
 
2557
    the modulus R in    R = M mod N
 
2558
 
 
2559
   is defined as
 
2560
 
 
2561
     0 <= |R| < |M|
 
2562
     sign R == sign M
 
2563
     R = M - k*N, where k is integer
 
2564
 
 
2565
   thus, there's no requirement for M or N to be integers
2549
2566
*/
 
2567
 
2550
2568
int decimal_mod(const decimal_t *from1, const decimal_t *from2, decimal_t *to)
2551
2569
{
2552
2570
  return do_div_mod(from1, from2, 0, to, 0);
2553
2571
}
2554
2572
 
2555
 
std::ostream& operator<<(std::ostream& output, const type::Decimal &dec)
2556
 
{
2557
 
  drizzled::String str;
2558
 
 
2559
 
  class_decimal2string(&dec, 0, &str);
2560
 
 
2561
 
  output << "type::Decimal:(";
2562
 
  output <<  str.c_ptr();
2563
 
  output << ")";
2564
 
 
2565
 
  return output;  // for multiple << operators.
2566
 
}
2567
 
 
2568
2573
} /* namespace drizzled */
2569
2574
 
2570
2575
#ifdef MAIN
2577
2582
{
2578
2583
  int i;
2579
2584
  printf("/* intg=%d, frac=%d, sign=%d, buf[]={", d->intg, d->frac, d->sign);
2580
 
  for (i=0; i < round_up(d->frac)+round_up(d->intg)-1; i++)
 
2585
  for (i=0; i < ROUND_UP(d->frac)+ROUND_UP(d->intg)-1; i++)
2581
2586
    printf("%09d, ", d->buf[i]);
2582
2587
  printf("%09d} */ ", d->buf[i]);
2583
2588
}
3298
3303
 
3299
3304
  return 0;
3300
3305
}
3301
 
 
3302
3306
#endif