[BACK]Return to interval.h CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / include

Diff for /OpenXM_contrib2/asir2000/include/interval.h between version 1.4 and 1.16

version 1.4, 2002/01/04 17:01:40 version 1.16, 2019/06/04 07:11:22
Line 1 
Line 1 
 /*  /*
  * $OpenXM: OpenXM_contrib2/asir2000/include/interval.h,v 1.3 2001/03/19 01:13:50 noro Exp $   * $OpenXM: OpenXM_contrib2/asir2000/include/interval.h,v 1.15 2018/03/29 01:32:53 noro Exp $
 */  */
 #ifndef _INTERVAL_H  #ifndef  _INTERVAL_H
 #define _INTERVAL_H  #define  _INTERVAL_H
   
 #define PRINTF_G        0  #define       INT_ASIR_VERSION        20181218
 #define PRINTF_E        1  
   
   #define  PRINTF_G  0
   #define  PRINTF_E  1
   
 #if defined(INTERVAL)  #if defined(INTERVAL)
   
 #include <math.h>  #include <math.h>
   
 #ifdef  sun  #ifdef  sun
 #if OSMajorVersion < 4 || (OSMajorVersion == 4 && OSMinorVersion < 1)  #if OSMajorVersion < 4 || (OSMajorVersion == 4 && OSMinorVersion < 1)
 #include <sys/ieeefp.h>  #include <sys/ieeefp.h>
 #endif  #endif
 #if defined(__svr4__)  #if defined(__svr4__)
 #include        <ieeefp.h>  #include  <ieeefp.h>
 #define FPNEAREST       fpsetround(FP_RN);  #define  FPNEAREST  fpsetround(FP_RN);
 #define FPPLUSINF       fpsetround(FP_RP);  #define  FPPLUSINF  fpsetround(FP_RP);
 #define FPMINUSINF      fpsetround(FP_RM);  #define  FPMINUSINF  fpsetround(FP_RM);
 #define FPTOZERO        fpsetround(FP_RZ);  #define  FPTOZERO  fpsetround(FP_RZ);
 #else  #else
 static char     *Interval_dummy;  static char  *Interval_dummy;
 #define FPNEAREST       ieee_flags("clear", "direction", Interval_dummy, &Interval_dummy);  #define  FPNEAREST  ieee_flags("clear", "direction", Interval_dummy, &Interval_dummy);
 #define FPPLUSINF       ieee_flags("set", "direction", "positive", &Interval_dummy);  #define  FPPLUSINF  ieee_flags("set", "direction", "positive", &Interval_dummy);
 #define FPMINUSINF      ieee_flags("set", "direction", "negative", &Interval_dummy);  #define  FPMINUSINF  ieee_flags("set", "direction", "negative", &Interval_dummy);
 #define FPTOZERO        ieee_flags("set", "direction", "tozero", &Interval_dummy);  #define  FPTOZERO  ieee_flags("set", "direction", "tozero", &Interval_dummy);
 #endif  #endif
 #endif  #endif
   
 #ifdef  linux  #if 0
 #include        <fpu_control.h>  #ifdef  linux
   #include  <fpu_control.h>
 #if 1  #if 1
 #define LINUX_FPU_RC_MASK                               0xf3ff  
 #define LINUX_FPU_SETCW(c)                      {_FPU_GETCW(__fpu_control);\  #if defined(__ARM_ARCH) || defined(ANDROID)
                                 _FPU_SETCW(__fpu_control & LINUX_FPU_RC_MASK | c);}  #ifndef _FPU_RC_NEAREST
 #define FPNEAREST       LINUX_FPU_SETCW(_FPU_RC_NEAREST);  #define _FPU_RC_NEAREST 0x0
 #define FPPLUSINF       LINUX_FPU_SETCW(_FPU_RC_UP);  #endif
 #define FPMINUSINF      LINUX_FPU_SETCW(_FPU_RC_DOWN);  #ifndef _FPU_RC_DOWN
 #define FPTOZERO                LINUX_FPU_SETCW(_FPU_RC_ZERO);  #define _FPU_RC_DOWN    0x400
   #endif
   #ifndef _FPU_RC_UP
   #define _FPU_RC_UP      0x800
   #endif
   #ifndef _FPU_RC_ZERO
   #define _FPU_RC_ZERO    0xC00
   #endif
   #endif /* __ARM_ARCH */
   
   #define  LINUX_FPU_RC_MASK        0xf3ff
   #define  LINUX_FPU_SETCW(c)      \
   {fpu_control_t __tmp__; _FPU_GETCW(__fpu_control);\
    __tmp__ = (__fpu_control & LINUX_FPU_RC_MASK | c);\
    _FPU_SETCW(__tmp__);}
   #define  FPNEAREST  LINUX_FPU_SETCW(_FPU_RC_NEAREST);
   #define  FPPLUSINF  LINUX_FPU_SETCW(_FPU_RC_UP);
   #define  FPMINUSINF  LINUX_FPU_SETCW(_FPU_RC_DOWN);
   #define  FPTOZERO    LINUX_FPU_SETCW(_FPU_RC_ZERO);
 #else  #else
 #define _FPU_DEFAULT_p_FPU_RC_UP        0x1b72  #define  _FPU_DEFAULT_p_FPU_RC_UP  0x1b72
 #define _FPU_DEFAULT_p_FPU_RC_DOWN      0x1772  #define  _FPU_DEFAULT_p_FPU_RC_DOWN  0x1772
 #define _FPU_DEFAULT_p_FPU_RC_ZERO      0x1f72  #define  _FPU_DEFAULT_p_FPU_RC_ZERO  0x1f72
 #define FPNEAREST       __setfpucw(_FPU_DEFAULT);  #define  FPNEAREST  __setfpucw(_FPU_DEFAULT);
 #define FPPLUSINF       __setfpucw(_FPU_DEFAULT_p_FPU_RC_UP);  #define  FPPLUSINF  __setfpucw(_FPU_DEFAULT_p_FPU_RC_UP);
 #define FPMINUSINF      __setfpucw(_FPU_DEFAULT_p_FPU_RC_DOWN);  #define  FPMINUSINF  __setfpucw(_FPU_DEFAULT_p_FPU_RC_DOWN);
 #define FPTOZERO        __setfpucw(_FPU_DEFAULT_p_FPU_RC_ZERO);  #define  FPTOZERO  __setfpucw(_FPU_DEFAULT_p_FPU_RC_ZERO);
 #endif  #endif
 #endif  #endif
   
 #if defined(__osf__)  #if defined(__osf__)
 #if 0  #if 0
 #include        <float.h>  #include  <float.h>
 #define FPNEAREST       write_rnd(FP_RND_RN);  #define  FPNEAREST  write_rnd(FP_RND_RN);
 #define FPPLUSINF       write_rnd(FP_RND_RP);  #define  FPPLUSINF  write_rnd(FP_RND_RP);
 #define FPMINUSINF      write_rnd(FP_RND_RM);  #define  FPMINUSINF  write_rnd(FP_RND_RM);
 #define FPTOZERO        write_rnd(FP_RND_RZ);  #define  FPTOZERO  write_rnd(FP_RND_RZ);
 #else  #else
 #define FPNEAREST  #define  FPNEAREST
 #define FPPLUSINF  #define  FPPLUSINF
 #define FPMINUSINF  #define  FPMINUSINF
 #define FPTOZERO  #define  FPTOZERO
 #endif  #endif
 #endif  #endif
   
 #if defined(__FreeBSD__)  #if defined(__FreeBSD__) && defined(__GNUC__)
 #include        <floatingpoint.h>  #include  <floatingpoint.h>
 #define FPNEAREST       fpsetround(FP_RN);  #define  FPNEAREST  fpsetround(FP_RN);
 #define FPPLUSINF       fpsetround(FP_RP);  #define  FPPLUSINF  fpsetround(FP_RP);
 #define FPMINUSINF      fpsetround(FP_RM);  #define  FPMINUSINF  fpsetround(FP_RM);
 #define FPTOZERO        fpsetround(FP_RZ);  #define  FPTOZERO  fpsetround(FP_RZ);
 #endif  #endif
   
   #if defined(VISUAL) || defined(__MINGW32__)
   #include <float.h>
   #define FPNEAREST _controlfp(_RC_NEAR,_MCW_RC);
   #define FPPLUSINF _controlfp(_RC_UP,_MCW_RC);
   #define FPMINUSINF _controlfp(_RC_DOWN,_MCW_RC);
   #define FPTOZERO _controlfp(_RC_CHOP,_MCW_RC);
   #endif
   #endif
   #include <fenv.h>
   
   #define FPNEAREST       fesetround(FE_TONEAREST);
   #define FPPLUSINF       fesetround(FE_UPWARD);
   #define FPMINUSINF      fesetround(FE_DOWNWARD);
   #define FPTOZERO        fesetround(FE_TOWARDZERO);
   
   
 /* no control function of floating point rounding */  /* no control function of floating point rounding */
 #ifndef FPNEAREST  #ifndef FPNEAREST
 #define FPNEAREST       fprintf(stderr, "Fpu control FPNEAREST is not supported in this machine yet.\n");  #define  FPNEAREST  fprintf(stderr, "Fpu control FPNEAREST is not supported in this machine yet.\n");
 #endif  #endif
 #ifndef FPMINUSINF  #ifndef FPMINUSINF
 #define FPMINUSINF      fprintf(stderr, "Fpu control FPMINUSINF is not supported in this machine yet.\n");  #define  FPMINUSINF  fprintf(stderr, "Fpu control FPMINUSINF is not supported in this machine yet.\n");
 #endif  #endif
 #ifndef FPPLUSINF  #ifndef FPPLUSINF
 #define FPPLUSINF       fprintf(stderr, "Fpu control FPPLUSINF is not supported in this machine yet.\n");  #define  FPPLUSINF  fprintf(stderr, "Fpu control FPPLUSINF is not supported in this machine yet.\n");
 #endif  #endif
 #ifndef FPTOZERO  #ifndef FPTOZERO
 #define FPTOZERO        fprintf(stderr, "Fpu control FPZERO is not supported in this machine yet.\n");  #define  FPTOZERO  fprintf(stderr, "Fpu control FPZERO is not supported in this machine yet.\n");
 #endif  #endif
 #define FPCLEAR         FPNEAREST  #define FPCLEAR    FPNEAREST
   
 #define MID_PRINTF_G    2  #define  MID_PRINTF_G  2
 #define MID_PRINTF_E    3  #define  MID_PRINTF_E  3
   
 #undef  N_C  #define DEFAULTPREC     0       /* for mpfr */
 #undef  N_M  
 #undef  N_LM  
 #undef  N_GF2N  
 #undef  N_GFPN  
 #undef  N_GFS  
 #undef  N_GFSN  
 #define N_IP    (N_B+1)  
 #define N_ID    (N_B+2)  
 #define N_IT    (N_B+3)  
 #define N_IF    (N_B+4)  
 #define N_PRE_C N_IF  
 #define N_C     (N_B+5)  
 #define N_M     (N_B+6)  
 #define N_LM    (N_B+7)  
 #define N_GF2N  (N_B+8)  
 #define N_GFPN  (N_B+9)  
 #define N_GFS   (N_B+10)  
 #define N_GFSN (N_B+11)  
   
 /* data structures */  /* data structures */
 struct oItv {  struct oItv {
         short   id;          short  id;
         char    nid;          char  nid;
         char    pad;          char  pad;
         Num     inf;          Num  inf;
         Num     sup;          Num  sup;
 };  };
   
 typedef struct oItv *Itv;  typedef struct oItv *Itv;
   
 struct oItvD {  struct oIntervalDouble {
         short   id;          short  id;
         char    nid;          char  nid;
         char    pad;          char  pad;
         double  inf;          double  inf;
         double  sup;          double  sup;
 };  };
   
 typedef struct oItvD *ItvD;  typedef struct oIntervalDouble *IntervalDouble;
   
 struct oforth {  struct oforth {
         short   sign;    short  sign;
         short   exp;    short  exp;
         double  u;    double  u;
         double  l;    double  l;
 };  };
   
 typedef struct oforth *forth;  typedef struct oforth *forth;
   
 struct oItvT {  struct oIntervalQuad {
         short   id;          short  id;
         char    nid;          char  nid;
         char    pad;          char  pad;
         forth   inf;          forth  inf;
         forth   sup;          forth  sup;
 };  };
   
 typedef struct oItvT *ItvT;  typedef struct oIntervalQuad *IntervalQuad;
   
 struct oItvF {  struct oIntervalBigFloat {
         short   id;          short  id;
         char    nid;          char  nid;
         char    pad;          char  pad;
         BF      inf;          BF  inf;
         BF      sup;          BF  sup;
 };  };
   
 typedef struct oItvF *ItvF;  typedef struct oIntervalBigFloat *IntervalBigFloat;
   
 extern int zerorewrite;  extern int zerorewrite;
   extern int zerorewriteCount;
   
 /* general macros */  /* general macros */
 #define INF(p)  ((p)->inf)  #define INF(p)  ((p)->inf)
 #define SUP(p)  ((p)->sup)  #define SUP(p)  ((p)->sup)
   
 #define NEWItvP(q)      ((q)=(Itv)MALLOC(sizeof(struct oItv)),\  #define NEWItvP(q)  ((q)=(Itv)MALLOC(sizeof(struct oItv)),\
                                         OID(q)=O_N,NID(q)=N_IP)            OID(q)=O_N,NID(q)=N_IP)
 #define NEWItvD(q)      ((q)=(ItvD)MALLOC(sizeof(struct oItvD)),\  #define NEWIntervalDouble(q)  ((q)=(IntervalDouble)MALLOC(sizeof(struct oIntervalDouble)),\
                                         OID(q)=O_N,NID(q)=N_ID)            OID(q)=O_N,NID(q)=N_IntervalDouble)
 #define NEWItvT(q)      ((q)=(ItvD)MALLOC(sizeof(struct oItvT)),\  #define NEWIntervalQuad(q)  ((q)=(IntervalDouble)MALLOC(sizeof(struct oIntervalQuad)),\
                                         OID(q)=O_N,NID(q)=N_IT)            OID(q)=O_N,NID(q)=N_IntervalQuad)
 #define NEWItvF(q)      ((q)=(ItvF)MALLOC(sizeof(struct oItvF)),\  #define NEWIntervalBigFloat(q)  ((q)=(IntervalBigFloat)MALLOC(sizeof(struct oIntervalBigFloat)),\
                                         OID(q)=O_N,NID(q)=N_IF)            OID(q)=O_N,NID(q)=N_IntervalBigFloat)
 #define MKItvP(a,b,c)   (NEWItvP(c),(INF(c)=(a),SUP(c)=(b)))  #define MKItvP(a,b,c)  (NEWItvP(c),(INF(c)=(a),SUP(c)=(b)))
 #define MKItvD(a,b,c)   if((zerorewrite) && ((a)<=0.0) && ((b)>=0.0)) (c)=0;\  #define MKIntervalDouble(a,b,c)  if((zerorewrite) && ((a)<=0.0) && ((b)>=0.0)) {(c)=0;zerorewriteCount++;}\
                         else (NEWItvD(c),(INF(c)=(a),SUP(c)=(b)))          else (NEWIntervalDouble(c),(INF(c)=(a),SUP(c)=(b)))
 #define MKItvT(a,b,c)   (NEWItvT(c),(INF(c)=(a),SUP(c)=(b)))  #define MKIntervalQuad(a,b,c)  (NEWIntervalQuad(c),(INF(c)=(a),SUP(c)=(b)))
 #define MKItvF(a,b,c)   (NEWItvF(c),(INF(c)=(a),SUP(c)=(b)))  #define MKIntervalBigFloat(a,b,c)  (NEWIntervalBigFloat(c),(INF(c)=(a),SUP(c)=(b)))
   
 #define ToItvP(a,c)     (NEWItvP(c),INF(c)=(a),SUP(c)=(a))  #define ToItvP(a,c)  (NEWItvP(c),INF(c)=(a),SUP(c)=(a))
 #define ToItvD(a,c)     (NEWItvD(c),INF(c)=(ToReal(a)),SUP(c)=(ToReal(a)))  #define ToIntervalDouble(a,c)  (NEWIntervalDouble(c),INF(c)=(ToReal(a)),SUP(c)=(ToReal(a)))
 #define ToItvF(a,c)     (NEWItvF(c),INF(c)=(a),SUP(c)=(a))  #define ToIntervalBigFloat(a,c)  (NEWIntervalBigFloat(c),INF(c)=(a),SUP(c)=(a))
   
 #define ITVP(a) (NID(a)==N_IP)  #define ITVP(a) (NID(a)==N_IP)
 #define ITVD(a) (NID(a)==N_ID)  #define ITVD(a) (NID(a)==N_IntervalDouble)
 #define ITVT(a) (NID(a)==N_IT)  #define ITVQ(a) (NID(a)==N_IntervalQuad)
 #define ITVF(a) (NID(a)==N_IF)  #define ITVF(a) (NID(a)==N_IntervalBigFloat)
   
 /***    engine/itv.c    ***/  #if 0
 double  ToRealSup(Num);  double  ToRealSup(Num);
 double  ToRealInf(Num);  double  ToRealInf(Num);
 double  RatnToRealUp(Q);  double  RatnToRealUp(Q);
 double  NatToRealUp(N, int *);  double  NatToRealUp(N, int *);
   
 void    double2bf(double, BF *);  void  double2bf(double, BF *);
 double  bf2double(BF);  double  bf2double(BF);
   
 void    itvtois(Itv, Num *, Num *);  
 void    istoitv(Num, Num, Itv *);  
   
 #if 0  
 void    additv(Num, Num, Num *);  void    additv(Num, Num, Num *);
 void    subitv(Num, Num, Num *);  void    subitv(Num, Num, Num *);
 void    mulitv(Num, Num, Num *);  void    mulitv(Num, Num, Num *);
Line 222  void    widthitv(Itv, Num *);
Line 239  void    widthitv(Itv, Num *);
 void    distanceitv(Itv, Itv, Num *);  void    distanceitv(Itv, Itv, Num *);
 #endif  #endif
   
   /***    engine/p-itv.c    ***/
   void  itvtois(Itv, Num *, Num *);
   void  istoitv(Num, Num, Itv *);
   
 void    additvp(Itv, Itv, Itv *);  void    additvp(Itv, Itv, Itv *);
 void    subitvp(Itv, Itv, Itv *);  void    subitvp(Itv, Itv, Itv *);
 void    mulitvp(Itv, Itv, Itv *);  void    mulitvp(Itv, Itv, Itv *);
 void    divitvp(Itv, Itv, Itv *);  void    divitvp(Itv, Itv, Itv *);
 void    chsgnitvp(Itv, Itv *);  
 int     cmpitvp(Itv, Itv);  
 void    pwritvp(Itv, Num, Itv *);  void    pwritvp(Itv, Num, Itv *);
 void    pwritv0p(Itv, int, Itv *);  void    pwritv0p(Itv, int, Itv *);
   void    chsgnitvp(Itv, Itv *);
   int     initvp(Num , Itv );
   int     itvinitvp(Itv, Itv);
   int     cmpitvp(Itv, Itv);
   void miditvp(Itv, Num *);
 void    cupitvp(Itv, Itv, Itv *);  void    cupitvp(Itv, Itv, Itv *);
 void    capitvp(Itv, Itv, Itv *);  void    capitvp(Itv, Itv, Itv *);
 void    widthitvp(Itv, Num *);  void    widthitvp(Itv, Num *);
   void absitvp(Itv, Num *);
 void    distanceitvp(Itv, Itv, Num *);  void    distanceitvp(Itv, Itv, Num *);
   
 void    ToBf(Num, BF *);  
 void    double2bf(double, BF *);  
 double  bf2double(BF);  
 void    addulp(ItvF, ItvF *);  
 void    getulp(BF, BF *);  
   
 void    additvf(ItvF, ItvF, ItvF *);  /***    engine/f-itv.c    ***/
 void    subitvf(ItvF, ItvF, ItvF *);  
 void    mulitvf(ItvF, ItvF, ItvF *);  //void  ToBf(Num, BF *);
 void    divitvf(ItvF, ItvF, ItvF *);  //void  double2bf(double, BF *);
 void    chsgnitvf(Itv, Itv *);  //double  bf2double(BF);
   //void  addulp(IntervalBigFloat, IntervalBigFloat *);
   //void  getulp(BF, BF *);
   
   void    additvf(IntervalBigFloat, IntervalBigFloat, IntervalBigFloat *);
   void    subitvf(IntervalBigFloat, IntervalBigFloat, IntervalBigFloat *);
   void    mulitvf(IntervalBigFloat, IntervalBigFloat, IntervalBigFloat *);
   void    divitvf(IntervalBigFloat, IntervalBigFloat, IntervalBigFloat *);
   void    chsgnitvf(IntervalBigFloat, IntervalBigFloat *);
   int     initvf(Num, Itv);
   int     itvinitvf(Itv, Itv);
 int     cmpitvf(Itv, Itv);  int     cmpitvf(Itv, Itv);
 void    pwritvf(Itv, Num, Itv *);  void    pwritvf(Itv, Num, Itv *);
 void    pwritv0f(Itv, int, Itv *);  void    pwritv0f(Itv, int, Itv *);
   void miditvf(Itv, Num *);
   void cupitvf(Itv, Itv, Itv *);
   void capitvf(Itv, Itv, Itv *);
   void widthitvf(Itv, Num *);
   void absitvf(Itv, Num *);
   void distanceitvf(Itv, Itv, Num *);
   
 /***    engine/d-itv.c    ***/  /***    engine/d-itv.c    ***/
 double  ToRealDown(Num);  double  ToRealDown(Num);
 double  ToRealUp(Num);  double  ToRealUp(Num);
 void    Num2double(Num, double *, double *);  void  Num2double(Num, double *, double *);
   
 void    additvd(Num, Num, ItvD *);  void    additvd(Num, Num, IntervalDouble *);
 void    subitvd(Num, Num, ItvD *);  void    subitvd(Num, Num, IntervalDouble *);
 void    mulitvd(Num, Num, ItvD *);  void    mulitvd(Num, Num, IntervalDouble *);
 void    divitvd(Num, Num, ItvD *);  void    divitvd(Num, Num, IntervalDouble *);
 void    chsgnitvd(ItvD, ItvD *);  void    chsgnitvd(IntervalDouble, IntervalDouble *);
 int     cmpitvd(ItvD, ItvD);  int     initvd(Num, IntervalDouble);
 void    pwritvd(Num, Num, ItvD *);  int     cmpitvd(IntervalDouble, IntervalDouble);
 void    pwritv0d(ItvD, int, ItvD *);  void    pwritvd(Num, Num, IntervalDouble *);
 void    miditvd(ItvD, Num *);  void    pwritv0d(IntervalDouble, int, IntervalDouble *);
 void    cupitvd(ItvD, ItvD, ItvD *);  void    miditvd(IntervalDouble, Num *);
 void    capitvd(ItvD, ItvD, ItvD *);  void    cupitvd(IntervalDouble, IntervalDouble, IntervalDouble *);
 void    widthitvd(ItvD, Num *);  void    capitvd(IntervalDouble, IntervalDouble, IntervalDouble *);
 void    absitvd(ItvD, Num *);  void    widthitvd(IntervalDouble, Num *);
 void    distanceitvd(ItvD, ItvD, Num *);  void    absitvd(IntervalDouble, Num *);
   void    distanceitvd(IntervalDouble, IntervalDouble, Num *);
   
 #endif /* end of INTERVAL */  #endif /* end of INTERVAL */
 #endif /* end of _INTERVAL_H */  #endif /* end of _INTERVAL_H */
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.16
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>