← Back to branch summary

~ubuntu-branches/ubuntu/trusty/xfractint/trusty

« back to all changes in this revision

Viewing changes to headers/mpmath.h

  • Committer: Bazaar Package Importer
  • Author(s): Riku Voipio
  • Date: 2010-11-24 21:24:54 UTC
  • mfrom: (1.2.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20101124212454-a2vxdh9pk5p5lhlm
Tags: 20.4.10-1
http://bugs.debian.org/410674
http://bugs.debian.org/587959
http://bugs.debian.org/449889
http://bugs.debian.org/581474
* New upstream version
* enable autobuilding, Closes: #410674, #587959
* update watch file. Closes: #449889
* remove bashism from rules, Closes: #581474

Show diffs side-by-side

added added

removed removed

Lines of Context:
headers/mpmath.h
 
1
/*
 
2
 *  REMOVED FORMAL PARAMETERS FROM FUNCTION DEFINITIONS (1/4/92)
 
3
 */
 
4
 
 
5
 
 
6
#ifndef MPMATH_H
 
7
#define MPMATH_H
 
8
 
 
9
#ifndef _CMPLX_DEFINED
 
10
#include "cmplx.h"
 
11
#endif
 
12
 
 
13
#ifdef XFRACT
 
14
#define far
 
15
#endif
 
16
 
 
17
 
 
18
#ifndef XFRACT
 
19
struct MP {
 
20
   int Exp;
 
21
        unsigned long Mant;
 
22
};
 
23
#else
 
24
struct MP {
 
25
   double val;
 
26
};
 
27
#endif
 
28
 
 
29
struct MPC {
 
30
        struct MP x, y;
 
31
};
 
32
 
 
33
extern int MPOverflow;
 
34
extern int DivideOverflow;
 
35
 
 
36
/* Mark Peterson's expanded floating point operators.  Automatically uses
 
37
   either the 8086 or 80386 processor type specified in global 'cpu'. If
 
38
   the operation results in an overflow (result < 2**(2**14), or division
 
39
   by zero) the global 'MPoverflow' is set to one. */
 
40
 
 
41
/* function pointer support added by Tim Wegner 12/07/89 */
 
42
extern int         (*pMPcmp)(struct MP , struct MP );
 
43
extern struct MP  *(*pMPmul)(struct MP , struct MP );
 
44
extern struct MP  *(*pMPdiv)(struct MP , struct MP );
 
45
extern struct MP  *(*pMPadd)(struct MP , struct MP );
 
46
extern struct MP  *(*pMPsub)(struct MP , struct MP );
 
47
extern struct MP  *(*pd2MP)(double )                ;
 
48
extern double     *(*pMP2d)(struct MP )             ;
 
49
 
 
50
 
 
51
/*** Formula Declarations ***/
 
52
#ifndef XFRACT
 
53
enum MATH_TYPE { D_MATH, M_MATH, L_MATH };
 
54
#else
 
55
enum MATH_TYPE { D_MATH};
 
56
#endif
 
57
extern enum MATH_TYPE MathType;
 
58
 
 
59
#define fDiv(x, y, z) (void)((*(long*)&z) = RegDivFloat(*(long*)&x, *(long*)&y))
 
60
#define fMul16(x, y, z) (void)((*(long*)&z) = r16Mul(*(long*)&x, *(long*)&y))
 
61
#define fShift(x, Shift, z) (void)((*(long*)&z) = \
 
62
   RegSftFloat(*(long*)&x, Shift))
 
63
#define Fg2Float(x, f, z) (void)((*(long*)&z) = RegFg2Float(x, f))
 
64
#define Float2Fg(x, f) RegFloat2Fg(*(long*)&x, f)
 
65
#define fLog14(x, z) (void)((*(long*)&z) = \
 
66
        RegFg2Float(LogFloat14(*(long*)&x), 16))
 
67
#define fExp14(x, z) (void)((*(long*)&z) = ExpFloat14(*(long*)&x));
 
68
#define fSqrt14(x, z) fLog14(x, z); fShift(z, -1, z); fExp14(z, z)
 
69
 
 
70
/* the following are declared 4 dimensional as an experiment */
 
71
/* changeing declarations to _CMPLX and _LCMPLX restores the code */
 
72
/* to 2D */
 
73
union Arg {
 
74
   _CMPLX     d;
 
75
   struct MPC m;
 
76
   _LCMPLX    l;
 
77
/*
 
78
   _DHCMPLX   dh;
 
79
   _LHCMPLX   lh; */
 
80
};
 
81
 
 
82
struct ConstArg {
 
83
   char *s;
 
84
   int len;
 
85
   union Arg a;
 
86
};
 
87
 
 
88
extern union Arg *Arg1,*Arg2;
 
89
 
 
90
extern void lStkSin(void),lStkCos(void),lStkSinh(void),lStkCosh(void),lStkLog(void),lStkExp(void),lStkSqr(void);
 
91
extern void dStkSin(void),dStkCos(void),dStkSinh(void),dStkCosh(void),dStkLog(void),dStkExp(void),dStkSqr(void);
 
92
 
 
93
extern void (*ltrig0)(void);
 
94
extern void (*ltrig1)(void);
 
95
extern void (*ltrig2)(void);
 
96
extern void (*ltrig3)(void);
 
97
extern void (*dtrig0)(void);
 
98
extern void (*dtrig1)(void);
 
99
extern void (*dtrig2)(void);
 
100
extern void (*dtrig3)(void);
 
101
 
 
102
/* -------------------------------------------------------------------- */
 
103
/*   The following #defines allow the complex transcendental functions  */
 
104
/*   in parser.c to be used here thus avoiding duplicated code.         */
 
105
/* -------------------------------------------------------------------- */
 
106
#ifndef XFRACT
 
107
 
 
108
#define CMPLXmod(z)       (sqr((z).x)+sqr((z).y))
 
109
#define CMPLXconj(z)    ((z).y =  -((z).y))
 
110
#define LCMPLXmod(z)       (lsqr((z).x)+lsqr((z).y))
 
111
#define LCMPLXconj(z)   ((z).y =  -((z).y))
 
112
 
 
113
 
 
114
#define LCMPLXtrig0(arg,out) Arg1->l = (arg); ltrig0(); (out)=Arg1->l
 
115
#define LCMPLXtrig1(arg,out) Arg1->l = (arg); ltrig1(); (out)=Arg1->l
 
116
#define LCMPLXtrig2(arg,out) Arg1->l = (arg); ltrig2(); (out)=Arg1->l
 
117
#define LCMPLXtrig3(arg,out) Arg1->l = (arg); ltrig3(); (out)=Arg1->l
 
118
 
 
119
#endif /* XFRACT */
 
120
 
 
121
#define  CMPLXtrig0(arg,out) Arg1->d = (arg); dtrig0(); (out)=Arg1->d
 
122
#define  CMPLXtrig1(arg,out) Arg1->d = (arg); dtrig1(); (out)=Arg1->d
 
123
#define  CMPLXtrig2(arg,out) Arg1->d = (arg); dtrig2(); (out)=Arg1->d
 
124
#define  CMPLXtrig3(arg,out) Arg1->d = (arg); dtrig3(); (out)=Arg1->d
 
125
 
 
126
#ifndef XFRACT
 
127
 
 
128
#define LCMPLXsin(arg,out)   Arg1->l = (arg); lStkSin();  (out) = Arg1->l
 
129
#define LCMPLXcos(arg,out)   Arg1->l = (arg); lStkCos();  (out) = Arg1->l
 
130
#define LCMPLXsinh(arg,out)  Arg1->l = (arg); lStkSinh(); (out) = Arg1->l
 
131
#define LCMPLXcosh(arg,out)  Arg1->l = (arg); lStkCosh(); (out) = Arg1->l
 
132
#define LCMPLXlog(arg,out)   Arg1->l = (arg); lStkLog();  (out) = Arg1->l
 
133
#define LCMPLXexp(arg,out)   Arg1->l = (arg); lStkExp();  (out) = Arg1->l
 
134
/*
 
135
#define LCMPLXsqr(arg,out)   Arg1->l = (arg); lStkSqr();  (out) = Arg1->l
 
136
*/
 
137
#define LCMPLXsqr(arg,out)   \
 
138
   (out).x = lsqr((arg).x) - lsqr((arg).y);\
 
139
   (out).y = multiply((arg).x, (arg).y, bitshiftless1)
 
140
#define LCMPLXsqr_old(out)       \
 
141
   (out).y = multiply(lold.x, lold.y, bitshiftless1);\
 
142
   (out).x = ltempsqrx - ltempsqry
 
143
 
 
144
#define LCMPLXpwr(arg1,arg2,out)    Arg2->l = (arg1); Arg1->l = (arg2);\
 
145
         lStkPwr(); Arg1++; Arg2++; (out) = Arg2->l
 
146
#define LCMPLXmult(arg1,arg2,out)    Arg2->l = (arg1); Arg1->l = (arg2);\
 
147
         lStkMul(); Arg1++; Arg2++; (out) = Arg2->l
 
148
#define LCMPLXadd(arg1,arg2,out)    \
 
149
    (out).x = (arg1).x + (arg2).x; (out).y = (arg1).y + (arg2).y
 
150
#define LCMPLXsub(arg1,arg2,out)    \
 
151
    (out).x = (arg1).x - (arg2).x; (out).y = (arg1).y - (arg2).y
 
152
 
 
153
#define LCMPLXtimesreal(arg,real,out)   \
 
154
    (out).x = multiply((arg).x,(real),bitshift);\
 
155
    (out).y = multiply((arg).y,(real),bitshift)
 
156
 
 
157
#define LCMPLXrecip(arg,out)    \
 
158
{ long denom; denom = lsqr((arg).x) + lsqr((arg).y);\
 
159
if(denom==0L) overflow=1; else {(out).x = divide((arg).x,denom,bitshift);\
 
160
(out).y = -divide((arg).y,denom,bitshift);}}
 
161
#endif /* XFRACT */
 
162
 
 
163
#define CMPLXsin(arg,out)    Arg1->d = (arg); dStkSin();  (out) = Arg1->d
 
164
#define CMPLXcos(arg,out)    Arg1->d = (arg); dStkCos();  (out) = Arg1->d
 
165
#define CMPLXsinh(arg,out)   Arg1->d = (arg); dStkSinh(); (out) = Arg1->d
 
166
#define CMPLXcosh(arg,out)   Arg1->d = (arg); dStkCosh(); (out) = Arg1->d
 
167
#define CMPLXlog(arg,out)    Arg1->d = (arg); dStkLog();  (out) = Arg1->d
 
168
#define CMPLXexp(arg,out)    FPUcplxexp(&(arg), &(out))
 
169
/*
 
170
#define CMPLXsqr(arg,out)    Arg1->d = (arg); dStkSqr();  (out) = Arg1->d
 
171
*/
 
172
#define CMPLXsqr(arg,out)    \
 
173
   (out).x = sqr((arg).x) - sqr((arg).y);\
 
174
   (out).y = ((arg).x+(arg).x) * (arg).y
 
175
#define CMPLXsqr_old(out)       \
 
176
   (out).y = (old.x+old.x) * old.y;\
 
177
   (out).x = tempsqrx - tempsqry
 
178
 
 
179
#define CMPLXpwr(arg1,arg2,out)   (out)= ComplexPower((arg1), (arg2))
 
180
#define CMPLXmult1(arg1,arg2,out)    Arg2->d = (arg1); Arg1->d = (arg2);\
 
181
         dStkMul(); Arg1++; Arg2++; (out) = Arg2->d
 
182
#define CMPLXmult(arg1,arg2,out)  \
 
183
        {\
 
184
           _CMPLX TmP;\
 
185
           TmP.x = (arg1).x*(arg2).x - (arg1).y*(arg2).y;\
 
186
           TmP.y = (arg1).x*(arg2).y + (arg1).y*(arg2).x;\
 
187
           (out) = TmP;\
 
188
         }
 
189
#define CMPLXadd(arg1,arg2,out)    \
 
190
    (out).x = (arg1).x + (arg2).x; (out).y = (arg1).y + (arg2).y
 
191
#define CMPLXsub(arg1,arg2,out)    \
 
192
    (out).x = (arg1).x - (arg2).x; (out).y = (arg1).y - (arg2).y
 
193
#define CMPLXtimesreal(arg,real,out)   \
 
194
    (out).x = (arg).x*(real);\
 
195
    (out).y = (arg).y*(real)
 
196
 
 
197
#define CMPLXrecip(arg,out)    \
 
198
   { double denom; denom = sqr((arg).x) + sqr((arg).y);\
 
199
     if(denom==0.0) {(out).x = 1.0e10;(out).y = 1.0e10;}else\
 
200
    { (out).x =  (arg).x/denom;\
 
201
     (out).y = -(arg).y/denom;}}
 
202
 
 
203
#define CMPLXneg(arg,out)  (out).x = -(arg).x; (out).y = -(arg).y
 
204
 
 
205
#endif