ruby-dev

斎藤です。

BigDecimalには、数の丸めの機能が実装されていますが、どうせなら
JavaのBigDecimal互換の方がいいのではないでしょうか。
現状の「COMP_MODE」という名前ではちょっと抽象的な気もしますし、
ROUNDUPは「四捨五入」ではなく「切り上げ」という意味だと思います。

以下のパッチでは、RubyのBigDecimalにJava相当の機能を与えるため、とりあえず
・COMP_MODE* → ROUND*
・従来のROUNDUP → ROUND_HALF_UP(英語としてこちらが正しい)
・JavaのBigDecimalにあった丸めモード、
　ROUND_UP(単なる切り上げ)、ROUND_HALF_DOWN の追加
・...CEIL → ROUND_CEILING(ceilingのみ略称なのはおかしいと思ったので)
という事をやっています。また、ROUND_DOWNの別名としてROUND_TRUNCATEも
定義してみました。

とりあえず、.c と .h のみのパッチを、ちょっと大きいので添付ファイルと
してみました。取り込みを検討していただけますか? >小林さん

--
斎藤ただし

Attachments (1)

java-compatible-rounding.patch (8.6 KB, text/x-diff)

Index: bigdecimal.c
===================================================================
RCS file: /src/ruby/ext/bigdecimal/bigdecimal.c,v
retrieving revision 1.11
diff -u -p -r1.11 bigdecimal.c
--- bigdecimal.c	21 Jul 2003 14:49:25 -0000	1.11
+++ bigdecimal.c	22 Jul 2003 16:52:38 -0000
@@ -288,7 +288,7 @@ BigDecimal_mode(VALUE self, VALUE which,
         }
         return INT2FIX(fo);
     }
-    if(VP_COMP_MODE==f) {
+    if(VP_ROUND==f) {
         /* Computaion mode setting */
         if(TYPE(val)!=T_FIXNUM)     return Qnil;
         fo = VpSetCompMode((unsigned long)FIX2INT(val));
@@ -729,7 +729,7 @@ BigDecimal_DoDivmod(VALUE self, VALUE r,
     VpDivd(c, res, a, b);
     mx = c->Prec *(VpBaseFig() + 1);
     GUARD_OBJ(d,VpCreateRbObject(mx, "0"));
-    VpActiveRound(d,c,VP_COMP_MODE_FLOOR,0);
+    VpActiveRound(d,c,VP_ROUND_FLOOR,0);
     VpMult(res,d,b);
     VpAddSub(c,a,res,-1);
     *div = d;
@@ -776,7 +776,7 @@ BigDecimal_divremain(VALUE self, VALUE r
     GUARD_OBJ(d,VpCreateRbObject(mx, "0"));
     GUARD_OBJ(f,VpCreateRbObject(mx, "0"));
 
-    VpActiveRound(d,c,VP_COMP_MODE_TRUNCATE,0); /* 0: round off */
+    VpActiveRound(d,c,VP_ROUND_DOWN,0); /* 0: round down */
 
     VpFrac(f, c);
     VpMult(rr,f,b);
@@ -923,7 +923,7 @@ BigDecimal_fix(VALUE self)
     GUARD_OBJ(a,GetVpValue(self,1));
     mx = a->Prec *(VpBaseFig() + 1);
     GUARD_OBJ(c,VpCreateRbObject(mx, "0"));
-    VpActiveRound(c,a,VP_COMP_MODE_TRUNCATE,0); /* 0: round off */
+    VpActiveRound(c,a,VP_ROUND_DOWN,0); /* 0: round down */
     return ToValue(c);
 }
 
@@ -938,7 +938,7 @@ BigDecimal_round(int argc, VALUE *argv, 
     VALUE vLoc;
     VALUE vBanker;
     int na = rb_scan_args(argc,argv,"02",&vLoc,&vBanker);
-    sw = VP_COMP_MODE_ROUNDUP; /* round up */
+    sw = VP_ROUND_HALF_UP; /* round half up */
     switch(na) {
     case 0:
         iLoc = 0;
@@ -951,7 +951,7 @@ BigDecimal_round(int argc, VALUE *argv, 
         Check_Type(vLoc, T_FIXNUM);
         iLoc = FIX2INT(vLoc);
         Check_Type(vBanker, T_FIXNUM);
-        if(FIX2INT(vBanker)) sw = VP_COMP_MODE_EVEN; /* Banker's rounding */
+        if(FIX2INT(vBanker)) sw = VP_ROUND_HALF_EVEN; /* Banker's rounding */
         break;
     }
 
@@ -981,7 +981,7 @@ BigDecimal_truncate(int argc, VALUE *arg
     GUARD_OBJ(a,GetVpValue(self,1));
     mx = a->Prec *(VpBaseFig() + 1);
     GUARD_OBJ(c,VpCreateRbObject(mx, "0"));
-    VpActiveRound(c,a,VP_COMP_MODE_TRUNCATE,iLoc); /* 0: truncate */
+    VpActiveRound(c,a,VP_ROUND_DOWN,iLoc); /* 0: truncate */
     return ToValue(c);
 }
 
@@ -1018,7 +1018,7 @@ BigDecimal_floor(int argc, VALUE *argv, 
     GUARD_OBJ(a,GetVpValue(self,1));
     mx = a->Prec *(VpBaseFig() + 1);
     GUARD_OBJ(c,VpCreateRbObject(mx, "0"));
-    VpActiveRound(c,a,VP_COMP_MODE_FLOOR,iLoc);
+    VpActiveRound(c,a,VP_ROUND_FLOOR,iLoc);
     return ToValue(c);
 }
 
@@ -1041,7 +1041,7 @@ BigDecimal_ceil(int argc, VALUE *argv, V
     GUARD_OBJ(a,GetVpValue(self,1));
     mx = a->Prec *(VpBaseFig() + 1);
     GUARD_OBJ(c,VpCreateRbObject(mx, "0"));
-    VpActiveRound(c,a,VP_COMP_MODE_CEIL,iLoc);
+    VpActiveRound(c,a,VP_ROUND_CEILING,iLoc);
     return ToValue(c);
 }
 
@@ -1400,12 +1400,15 @@ Init_bigdecimal(void)
     rb_define_const(rb_cBigDecimal, "EXCEPTION_ZERODIVIDE",INT2FIX(VP_EXCEPTION_ZERODIVIDE));
 
     /* Computation mode */
-    rb_define_const(rb_cBigDecimal, "COMP_MODE",INT2FIX(VP_COMP_MODE));
-    rb_define_const(rb_cBigDecimal, "COMP_MODE_TRUNCATE",INT2FIX(VP_COMP_MODE_TRUNCATE));
-    rb_define_const(rb_cBigDecimal, "COMP_MODE_ROUNDUP",INT2FIX(VP_COMP_MODE_ROUNDUP));
-    rb_define_const(rb_cBigDecimal, "COMP_MODE_CEIL",INT2FIX(VP_COMP_MODE_CEIL));
-    rb_define_const(rb_cBigDecimal, "COMP_MODE_FLOOR",INT2FIX(VP_COMP_MODE_FLOOR));
-    rb_define_const(rb_cBigDecimal, "COMP_MODE_EVEN",INT2FIX(VP_COMP_MODE_EVEN));
+    rb_define_const(rb_cBigDecimal, "ROUND",INT2FIX(VP_ROUND));
+    rb_define_const(rb_cBigDecimal, "ROUND_TRUNCATE",INT2FIX(VP_ROUND_DOWN));
+    rb_define_const(rb_cBigDecimal, "ROUND_DOWN",INT2FIX(VP_ROUND_DOWN));
+    rb_define_const(rb_cBigDecimal, "ROUND_UP",INT2FIX(VP_ROUND_UP));
+    rb_define_const(rb_cBigDecimal, "ROUND_CEILING",INT2FIX(VP_ROUND_CEILING));
+    rb_define_const(rb_cBigDecimal, "ROUND_FLOOR",INT2FIX(VP_ROUND_FLOOR));
+    rb_define_const(rb_cBigDecimal, "ROUND_HALF_EVEN",INT2FIX(VP_ROUND_HALF_EVEN));
+    rb_define_const(rb_cBigDecimal, "ROUND_HALF_DOWN",INT2FIX(VP_ROUND_HALF_DOWN));
+    rb_define_const(rb_cBigDecimal, "ROUND_HALF_UP",INT2FIX(VP_ROUND_HALF_UP));
 
     /* Constants for sign value */
     rb_define_const(rb_cBigDecimal, "SIGN_NaN",INT2FIX(VP_SIGN_NaN));
@@ -1499,7 +1502,7 @@ static int gfCheckVal = 1;      /* Value
 #endif /* _DEBUG */
 
 static U_LONG gnPrecLimit = 0;  /* Global upper limit of the precision newly allocated */
-static short  gfCompMode  = VP_COMP_MODE_ROUNDUP; /* Mode for general computation */
+static short  gfCompMode  = VP_ROUND_HALF_UP; /* Mode for general computation */
 
 static U_LONG BASE_FIG = 4;     /* =log10(BASE)  */
 static U_LONG BASE = 10000L;    /* Base value(value must be 10**BASE_FIG) */
@@ -1593,8 +1596,9 @@ VP_EXPORT unsigned long
 VpSetCompMode(unsigned long n)
 {
     unsigned long s = gfCompMode;
-    if(n!=VP_COMP_MODE_TRUNCATE && n!= VP_COMP_MODE_ROUNDUP && n!=VP_COMP_MODE_CEIL &&
-       n!=VP_COMP_MODE_FLOOR    && n!= VP_COMP_MODE_EVEN)  return s;
+    if(n!=VP_ROUND_DOWN  && n!=VP_ROUND_UP        && n!=VP_ROUND_CEILING   &&
+       n!=VP_ROUND_FLOOR && n!=VP_ROUND_HALF_EVEN && n!=VP_ROUND_HALF_DOWN &&
+       n!=VP_ROUND_HALF_UP)  return s;
     gfCompMode = n;
     return s;
 }
@@ -3759,18 +3763,21 @@ VpActiveRound(Real *y, Real *x, int f, i
     div = v/10;
     v = v - div*10;
     switch(f) {
-    case VP_COMP_MODE_TRUNCATE: /* Truncate/Round off */
-         break;
-    case VP_COMP_MODE_ROUNDUP: /* Round up  */
+    case VP_ROUND_DOWN: /* Truncate/Round down */
+	break;
+    case VP_ROUND_UP:
+	++div;
+	break;
+    case VP_ROUND_HALF_UP: /* Round half up  */
         if(v>=5) ++div;
         break;
-    case VP_COMP_MODE_CEIL: /* ceil */
+    case VP_ROUND_CEILING: /* ceil */
         if(v && (VpGetSign(x)>0)) ++div;
         break;
-    case VP_COMP_MODE_FLOOR: /* floor */
+    case VP_ROUND_FLOOR: /* floor */
         if(v && (VpGetSign(x)<0)) ++div;
         break;
-    case VP_COMP_MODE_EVEN: /* Banker's rounding */
+    case VP_ROUND_HALF_EVEN: /* Banker's rounding */
         if(v>5) ++div;
         else if(v==5) {
             if(i==(BASE_FIG-1)) {
@@ -3780,6 +3787,9 @@ VpActiveRound(Real *y, Real *x, int f, i
             }
         }
         break;
+    case VP_ROUND_HALF_DOWN:
+        if(v>5) ++div;
+        break;
     }
     for(i=0;i<=n;++i) div *= 10;
     if(div>=BASE) {
@@ -3812,21 +3822,27 @@ VpInternalRound(Real *c,int ixDigit,U_LO
     int f = 0;
     v /= BASE1;
     switch(gfCompMode) {
-    case VP_COMP_MODE_TRUNCATE:
+    case VP_ROUND_DOWN:
         break;
-    case VP_COMP_MODE_ROUNDUP:
+    case VP_ROUND_UP:
+	f = 1;
+	break;
+    case VP_ROUND_HALF_UP:
         if(v >= 5)               f = 1;
         break;
-    case VP_COMP_MODE_CEIL: /* ceil */
+    case VP_ROUND_CEILING: /* ceil */
         if(v && (VpGetSign(c)>0)) f = 1;
         break;
-    case VP_COMP_MODE_FLOOR: /* floor */
+    case VP_ROUND_FLOOR: /* floor */
         if(v && (VpGetSign(c)<0)) f = 1;
         break;
-    case VP_COMP_MODE_EVEN: /* Banker's rounding */
+    case VP_ROUND_HALF_EVEN: /* Banker's rounding */
         if(v>5) f = 1;
         else if(v==5 && vPrev%2)  f = 1;
         break;
+    case VP_ROUND_HALF_DOWN:
+	if(v>5) f = 1;
+	break;
     }
     if(f) VpRdup(c,ixDigit);    /* round up */
     return f;
Index: bigdecimal.h
===================================================================
RCS file: /src/ruby/ext/bigdecimal/bigdecimal.h,v
retrieving revision 1.5
diff -u -p -r1.5 bigdecimal.h
--- bigdecimal.h	18 Jul 2003 15:23:23 -0000	1.5
+++ bigdecimal.h	22 Jul 2003 16:52:38 -0000
@@ -44,12 +44,14 @@ extern "C" {
 #define VP_EXCEPTION_MEMORY     ((unsigned short)0x0040)
 
 /* Computation mode */
-#define VP_COMP_MODE            ((unsigned short)0x0100)
-#define VP_COMP_MODE_TRUNCATE   0
-#define VP_COMP_MODE_ROUNDUP    1
-#define VP_COMP_MODE_CEIL       2
-#define VP_COMP_MODE_FLOOR      3
-#define VP_COMP_MODE_EVEN       4
+#define VP_ROUND                ((unsigned short)0x0100)
+#define VP_ROUND_DOWN           0
+#define VP_ROUND_UP             1
+#define VP_ROUND_CEILING        2
+#define VP_ROUND_FLOOR          3
+#define VP_ROUND_HALF_EVEN      4
+#define VP_ROUND_HALF_DOWN      5
+#define VP_ROUND_HALF_UP        6
 
 #define VP_SIGN_NaN                0 /* NaN                      */
 #define VP_SIGN_POSITIVE_ZERO      1 /* Positive zero            */

Thread

Prev Next

In This Thread

Prev Next