Return to round.c CVS log

Up to [local] / OpenXM_contrib2 / asir2018 / builtin

Annotation of OpenXM_contrib2/asir2018/builtin/round.c, Revision 1.1

1.1     ! noro        1: /* $OpenXM$ */
        !             2:
        !             3: #undef INTERVAL
        !             4: #define INTERVAL
        !             5: #include "ca.h"
        !             6: #include "parse.h"
        !             7: #include "interval.h"
        !             8:
        !             9: void Padd_pinf(),Padd_minf();
        !            10: void Psub_pinf(),Psub_minf();
        !            11: void Pmul_pinf(),Pmul_minf();
        !            12: void Pdiv_pinf(),Pdiv_minf();
        !            13:
        !            14: struct ftab round_tab[] = {
        !            15:   {"add_pinf",Padd_pinf,2},
        !            16:   {"add_minf",Padd_minf,2},
        !            17:   {"sub_pinf",Psub_pinf,2},
        !            18:   {"sub_minf",Psub_minf,2},
        !            19:   {"mul_pinf",Pmul_pinf,2},
        !            20:   {"mul_minf",Pmul_minf,2},
        !            21:   {"div_pinf",Pdiv_pinf,2},
        !            22:   {"div_minf",Pdiv_minf,2},
        !            23:   {0,0,0},
        !            24: };
        !            25:
        !            26: void Padd_pinf(NODE arg,Real *rp)
        !            27: {
        !            28:   Real a,b,r;
        !            29:   double c;
        !            30:
        !            31:   a = (Real)ARG0(arg);
        !            32:   b = (Real)ARG1(arg);
        !            33:   if ( !a )
        !            34:     *rp = b;
        !            35:   else if ( !b )
        !            36:     *rp = a;
        !            37:   else if ( NID(a) != N_R || NID(b) != N_R )
        !            38:     error("add_pinf : invalid argument");
        !            39:   else {
        !            40:     FPPLUSINF
        !            41:     c = BDY(a)+BDY(b);
        !            42:     FPNEAREST
        !            43:     MKReal(c,r);
        !            44:     *rp = r;
        !            45:   }
        !            46: }
        !            47:
        !            48: void Padd_minf(NODE arg,Real *rp)
        !            49: {
        !            50:   Real a,b,r;
        !            51:   double c;
        !            52:
        !            53:   a = (Real)ARG0(arg);
        !            54:   b = (Real)ARG1(arg);
        !            55:   if ( !a )
        !            56:     *rp = b;
        !            57:   else if ( !b )
        !            58:     *rp = a;
        !            59:   else if ( NID(a) != N_R || NID(b) != N_R )
        !            60:     error("add_pinf : invalid argument");
        !            61:   else {
        !            62:     FPMINUSINF
        !            63:     c = BDY(a)+BDY(b);
        !            64:     FPNEAREST
        !            65:     MKReal(c,r);
        !            66:     *rp = r;
        !            67:   }
        !            68: }
        !            69:
        !            70: void Psub_pinf(NODE arg,Real *rp)
        !            71: {
        !            72:   Real a,b,r;
        !            73:   double c;
        !            74:
        !            75:   a = (Real)ARG0(arg);
        !            76:   b = (Real)ARG1(arg);
        !            77:   if ( !a ) {
        !            78:     if ( !b )
        !            79:       *rp = 0;
        !            80:     else {
        !            81:       c = -BDY(b);
        !            82:       MKReal(c,r);
        !            83:       *rp = r;
        !            84:     }
        !            85:   } else if ( !b )
        !            86:     *rp = a;
        !            87:   else if ( NID(a) != N_R || NID(b) != N_R )
        !            88:     error("sub_pinf : invalid argument");
        !            89:   else {
        !            90:     FPPLUSINF
        !            91:     c = BDY(a)-BDY(b);
        !            92:     FPNEAREST
        !            93:     MKReal(c,r);
        !            94:     *rp = r;
        !            95:   }
        !            96: }
        !            97:
        !            98: void Psub_minf(NODE arg,Real *rp)
        !            99: {
        !           100:   Real a,b,r;
        !           101:   double c;
        !           102:
        !           103:   a = (Real)ARG0(arg);
        !           104:   b = (Real)ARG1(arg);
        !           105:   if ( !a ) {
        !           106:     if ( !b )
        !           107:       *rp = 0;
        !           108:     else {
        !           109:       c = -BDY(b);
        !           110:       MKReal(c,r);
        !           111:       *rp = r;
        !           112:     }
        !           113:   } else if ( !b )
        !           114:     *rp = a;
        !           115:   else if ( NID(a) != N_R || NID(b) != N_R )
        !           116:     error("sub_minf : invalid argument");
        !           117:   else {
        !           118:     FPMINUSINF
        !           119:     c = BDY(a)-BDY(b);
        !           120:     FPNEAREST
        !           121:     MKReal(c,r);
        !           122:     *rp = r;
        !           123:   }
        !           124: }
        !           125:
        !           126: void Pmul_pinf(NODE arg,Real *rp)
        !           127: {
        !           128:   Real a,b,r;
        !           129:   double c;
        !           130:
        !           131:   a = (Real)ARG0(arg);
        !           132:   b = (Real)ARG1(arg);
        !           133:   if ( !a || !b )
        !           134:     *rp = 0;
        !           135:   else if ( NID(a) != N_R || NID(b) != N_R )
        !           136:     error("mul_pinf : invalid argument");
        !           137:   else {
        !           138:     FPPLUSINF
        !           139:     c = BDY(a)*BDY(b);
        !           140:     FPNEAREST
        !           141:     MKReal(c,r);
        !           142:     *rp = r;
        !           143:   }
        !           144: }
        !           145:
        !           146: void Pmul_minf(NODE arg,Real *rp)
        !           147: {
        !           148:   Real a,b,r;
        !           149:   double c;
        !           150:
        !           151:   a = (Real)ARG0(arg);
        !           152:   b = (Real)ARG1(arg);
        !           153:   if ( !a || !b )
        !           154:     *rp = 0;
        !           155:   else if ( NID(a) != N_R || NID(b) != N_R )
        !           156:     error("mul_minf : invalid argument");
        !           157:   else {
        !           158:     FPMINUSINF
        !           159:     c = BDY(a)*BDY(b);
        !           160:     FPNEAREST
        !           161:     MKReal(c,r);
        !           162:     *rp = r;
        !           163:   }
        !           164: }
        !           165:
        !           166: void Pdiv_pinf(NODE arg,Real *rp)
        !           167: {
        !           168:   Real a,b,r;
        !           169:   double c;
        !           170:
        !           171:   a = (Real)ARG0(arg);
        !           172:   b = (Real)ARG1(arg);
        !           173:   if ( !b )
        !           174:     error("div_pinf : division by 0");
        !           175:   else if ( !a )
        !           176:     *rp = 0;
        !           177:   else if ( NID(a) != N_R || NID(b) != N_R )
        !           178:     error("div_pinf : invalid argument");
        !           179:   else {
        !           180:     FPPLUSINF
        !           181:     c = BDY(a)/BDY(b);
        !           182:     FPNEAREST
        !           183:     MKReal(c,r);
        !           184:     *rp = r;
        !           185:   }
        !           186: }
        !           187:
        !           188: void Pdiv_minf(NODE arg,Real *rp)
        !           189: {
        !           190:   Real a,b,r;
        !           191:   double c;
        !           192:
        !           193:   a = (Real)ARG0(arg);
        !           194:   b = (Real)ARG1(arg);
        !           195:   if ( !b )
        !           196:     error("div_minf : division by 0");
        !           197:   else if ( !a )
        !           198:     *rp = 0;
        !           199:   else if ( NID(a) != N_R || NID(b) != N_R )
        !           200:     error("div_minf : invalid argument");
        !           201:   else {
        !           202:     FPMINUSINF
        !           203:     c = BDY(a)/BDY(b);
        !           204:     FPNEAREST
        !           205:     MKReal(c,r);
        !           206:     *rp = r;
        !           207:   }
        !           208: }